diff --git a/.github/workflows/mega-linter.yml b/.github/workflows/mega-linter.yml new file mode 100644 index 0000000..42bce48 --- /dev/null +++ b/.github/workflows/mega-linter.yml @@ -0,0 +1,83 @@ +--- +# MegaLinter GitHub Action configuration file +# More info at https://megalinter.github.io +name: MegaLinter + +on: + # Trigger mega-linter at every push. Action will also be visible from Pull Requests to main + push: # Comment this line to trigger action only on pull-requests (not recommended if you don't pay for GH Actions) + pull_request: + branches: [master, main] + +env: # Comment env block if you do not want to apply fixes + # Apply linter fixes configuration + APPLY_FIXES: all # When active, APPLY_FIXES must also be defined as environment variable (in github/workflows/mega-linter.yml or other CI tool) + APPLY_FIXES_EVENT: pull_request # Decide which event triggers application of fixes in a commit or a PR (pull_request, push, all) + APPLY_FIXES_MODE: commit # If APPLY_FIXES is used, defines if the fixes are directly committed (commit) or posted in a PR (pull_request) + +concurrency: + group: ${{ github.ref }}-${{ github.workflow }} + cancel-in-progress: true + +jobs: + build: + name: MegaLinter + runs-on: ubuntu-latest + steps: + # Git Checkout + - name: Checkout Code + uses: actions/checkout@v2 + with: + token: ${{ secrets.PAT || secrets.GITHUB_TOKEN }} + fetch-depth: 0 + + # MegaLinter + - name: MegaLinter + id: ml + # You can override MegaLinter flavor used to have faster performances + # More info at https://megalinter.github.io/flavors/ + uses: megalinter/megalinter@v5 + env: + # All available variables are described in documentation + # https://megalinter.github.io/configuration/ + VALIDATE_ALL_CODEBASE: ${{ github.event_name == 'push' && github.ref == 'refs/heads/main' }} # Validates all source when push on main, else just the git diff with main. Override with true if you always want to lint all sources + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} + # ADD YOUR CUSTOM ENV VARIABLES HERE OR DEFINE THEM IN A FILE .mega-linter.yml AT THE ROOT OF YOUR REPOSITORY + # DISABLE: COPYPASTE,SPELL # Uncomment to disable copy-paste and spell checks + + # Upload MegaLinter artifacts + - name: Archive production artifacts + if: ${{ success() }} || ${{ failure() }} + uses: actions/upload-artifact@v2 + with: + name: MegaLinter reports + path: | + report + mega-linter.log + + # Create pull request if applicable (for now works only on PR from same repository, not from forks) + - name: Create Pull Request with applied fixes + id: cpr + if: steps.ml.outputs.has_updated_sources == 1 && (env.APPLY_FIXES_EVENT == 'all' || env.APPLY_FIXES_EVENT == github.event_name) && env.APPLY_FIXES_MODE == 'pull_request' && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository) + uses: peter-evans/create-pull-request@v4 + with: + token: ${{ secrets.PAT || secrets.GITHUB_TOKEN }} + commit-message: "[MegaLinter] Apply linters automatic fixes" + title: "[MegaLinter] Apply linters automatic fixes" + labels: bot + - name: Create PR output + if: steps.ml.outputs.has_updated_sources == 1 && (env.APPLY_FIXES_EVENT == 'all' || env.APPLY_FIXES_EVENT == github.event_name) && env.APPLY_FIXES_MODE == 'pull_request' && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository) + run: | + echo "Pull Request Number - ${{ steps.cpr.outputs.pull-request-number }}" + echo "Pull Request URL - ${{ steps.cpr.outputs.pull-request-url }}" + + # Push new commit if applicable (for now works only on PR from same repository, not from forks) + - name: Prepare commit + if: steps.ml.outputs.has_updated_sources == 1 && (env.APPLY_FIXES_EVENT == 'all' || env.APPLY_FIXES_EVENT == github.event_name) && env.APPLY_FIXES_MODE == 'commit' && github.ref != 'refs/heads/main' && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository) + run: sudo chown -Rc $UID .git/ + - name: Commit and push applied linter fixes + if: steps.ml.outputs.has_updated_sources == 1 && (env.APPLY_FIXES_EVENT == 'all' || env.APPLY_FIXES_EVENT == github.event_name) && env.APPLY_FIXES_MODE == 'commit' && github.ref != 'refs/heads/main' && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.repository) + uses: stefanzweifel/git-auto-commit-action@v4 + with: + branch: ${{ github.event.pull_request.head.ref || github.head_ref || github.ref }} + commit_message: "[MegaLinter] Apply linters fixes" diff --git a/.mega-linter.yml b/.mega-linter.yml new file mode 100644 index 0000000..921215e --- /dev/null +++ b/.mega-linter.yml @@ -0,0 +1,4 @@ +ENABLE: RUBY +ENABLE_LINTERS: + - SPELL_MISSPELL + - MARKDOWN_MARKDOWNLINT diff --git a/.rubocop.yml b/.rubocop.yml index a3f37bb..cf8cd6e 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -1 +1,6 @@ -require: rubocop-rspec +require: + - standard + - rubocop-rspec + +inherit_gem: + standard: config/base.yml diff --git a/firebase_dynamic_link.gemspec b/firebase_dynamic_link.gemspec index ce8b735..50834c7 100644 --- a/firebase_dynamic_link.gemspec +++ b/firebase_dynamic_link.gemspec @@ -28,6 +28,7 @@ Gem::Specification.new do |spec| spec.add_runtime_dependency 'dry-configurable', '>= 0.9', '< 1.0' spec.add_runtime_dependency 'faraday', '>= 0.16', '< 3.0' spec.add_runtime_dependency 'faraday-net_http', '>= 1.0', '< 3.0' + spec.add_runtime_dependency 'sorbet-runtime' spec.add_development_dependency 'appraisal', '~> 2.4.1' spec.add_development_dependency 'bootsnap', '~> 1.9.3' @@ -37,8 +38,11 @@ Gem::Specification.new do |spec| spec.add_development_dependency 'pry', '~> 0.14.1' spec.add_development_dependency 'rake', '>= 12.3.3' spec.add_development_dependency 'rspec', '~> 3.10.0' - spec.add_development_dependency 'rubocop', '~> 1.22' - spec.add_development_dependency 'rubocop-rspec', '~> 2.5.0' + spec.add_development_dependency 'rubocop', '~> 1.29.0' + spec.add_development_dependency 'rubocop-rspec', '~> 2.11.1' spec.add_development_dependency 'simplecov', '~> 0.17.1' + spec.add_development_dependency 'standard', '~> 1.12.1' + spec.add_development_dependency 'sorbet' + spec.add_development_dependency 'sord' spec.add_development_dependency 'vcr', '~> 4.0', '>= 4.0.0' end diff --git a/lib/firebase_dynamic_link.rb b/lib/firebase_dynamic_link.rb index 23d0de7..a57ae2b 100644 --- a/lib/firebase_dynamic_link.rb +++ b/lib/firebase_dynamic_link.rb @@ -1,12 +1,13 @@ +# typed: true # frozen_string_literal: true -require 'dry-configurable' -require 'dry/configurable/version' -require 'faraday' -require 'faraday/net_http' if Faraday::VERSION.to_f >= 2.0 -require 'firebase_dynamic_link/client' -require 'firebase_dynamic_link/link_renderer' -require 'firebase_dynamic_link/version' +require "dry-configurable" +require "dry/configurable/version" +require "faraday" +require "faraday/net_http" if Faraday::VERSION.to_f >= 2.0 +require "firebase_dynamic_link/client" +require "firebase_dynamic_link/link_renderer" +require "firebase_dynamic_link/version" module FirebaseDynamicLink extend Dry::Configurable @@ -105,23 +106,23 @@ class QuotaExceeded < StandardError; end # @since 1.0.0 # @!scope class if USE_DRY_CONFIGURABLE_0_13 - setting(:suffix_option, default: 'UNGUESSABLE', constructor: lambda { |value| + setting(:suffix_option, default: "UNGUESSABLE", constructor: lambda { |value| if %w[SHORT - UNGUESSABLE].include?(value) + UNGUESSABLE].include?(value) value else raise(FirebaseDynamicLink::InvalidConfig, - 'default suffix option config is not valid') + "default suffix option config is not valid") end }) else - setting(:suffix_option, 'UNGUESSABLE') do |value| + setting(:suffix_option, "UNGUESSABLE") do |value| if %w[SHORT - UNGUESSABLE].include?(value) + UNGUESSABLE].include?(value) value else raise(FirebaseDynamicLink::InvalidConfig, - 'default suffix option config is not valid') + "default suffix option config is not valid") end end diff --git a/lib/firebase_dynamic_link/client.rb b/lib/firebase_dynamic_link/client.rb index 0afaab6..59c3ab4 100644 --- a/lib/firebase_dynamic_link/client.rb +++ b/lib/firebase_dynamic_link/client.rb @@ -1,9 +1,10 @@ +# typed: true # frozen_string_literal: true -require 'uri' -require 'firebase_dynamic_link/connection' -require 'firebase_dynamic_link/link_renderer' -require 'case_transform2' +require "uri" +require "firebase_dynamic_link/connection" +require "firebase_dynamic_link/link_renderer" +require "case_transform2" module FirebaseDynamicLink # Main class that responsible to shorten link or parameters @@ -31,9 +32,9 @@ def shorten_link(link, options = {}) suffix_option = options[:suffix_option] if options.key?(:suffix_option) params = CaseTransform2.camel_lower(long_dynamic_link: build_link(link, options), - suffix: { - option: suffix_option || config.suffix_option - }) + suffix: { + option: suffix_option || config.suffix_option + }) response = connection.post(nil, params.to_json) link_renderer.render(response) rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e @@ -131,12 +132,12 @@ def shorten_parameters(params, options = {}) dynamic_link_domain = options.delete(:dynamic_link_domain) dynamic_link_domain ||= config.dynamic_link_domain || raise(FirebaseDynamicLink::InvalidConfig, - 'Dynamic link domain is empty') + "Dynamic link domain is empty") params = CaseTransform2.camel_lower(dynamic_link_info: params.merge(domainUriPrefix: dynamic_link_domain), - suffix: { - option: suffix_option || config.suffix_option - }) + suffix: { + option: suffix_option || config.suffix_option + }) response = connection.post(nil, params.to_json) link_renderer.render(response) rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e @@ -153,7 +154,7 @@ def shorten_parameters(params, options = {}) def build_link(link, options) dynamic_link_domain = options.delete(:dynamic_link_domain) dynamic_link_domain ||= config.dynamic_link_domain || raise(FirebaseDynamicLink::InvalidConfig, - 'Dynamic link domain is empty') + "Dynamic link domain is empty") "#{dynamic_link_domain}?link=#{link}" end diff --git a/lib/firebase_dynamic_link/connection.rb b/lib/firebase_dynamic_link/connection.rb index 1f0bb56..1d25d28 100644 --- a/lib/firebase_dynamic_link/connection.rb +++ b/lib/firebase_dynamic_link/connection.rb @@ -1,3 +1,4 @@ +# typed: true # frozen_string_literal: true module FirebaseDynamicLink @@ -11,7 +12,7 @@ class Connection def initialize(end_point) @client = Faraday::Connection.new(url: end_point, - headers: { 'Content-Type' => 'application/json' }) + headers: {"Content-Type" => "application/json"}) client.options.timeout = FirebaseDynamicLink.config.timeout client.options.open_timeout = FirebaseDynamicLink.config.open_timeout diff --git a/lib/firebase_dynamic_link/link_renderer.rb b/lib/firebase_dynamic_link/link_renderer.rb index d79f78c..63a6d30 100644 --- a/lib/firebase_dynamic_link/link_renderer.rb +++ b/lib/firebase_dynamic_link/link_renderer.rb @@ -1,9 +1,10 @@ +# typed: true # frozen_string_literal: true module FirebaseDynamicLink # Responsible to formatting output of Client#shorten_link class LinkRenderer - # @param response [Faraday::Connection] http reponse + # @param response [Faraday::Connection] http response # @return [Hash # @example # { @@ -27,12 +28,12 @@ def render(response) def render_success(response) body = JSON.parse(response.body) - return raise_error(response) if body.key?('error') + return raise_error(response) if body.key?("error") { - link: body['shortLink'], - preview_link: body['previewLink'], - warning: body['warning'] + link: body["shortLink"], + preview_link: body["previewLink"], + warning: body["warning"] } end @@ -40,15 +41,15 @@ def raise_error(response) reason = response.reason_phrase.to_s if response.respond_to?(:reason_phrase) message = begin body = JSON.parse(response.body) - body['error']['message'] + body["error"]["message"] rescue JSON::ParserError, NoMethodError response.body end - raise FirebaseDynamicLink::ConnectionError, [reason, message].compact.join(': ') + raise FirebaseDynamicLink::ConnectionError, [reason, message].compact.join(": ") end def raise_limit_has_reached - raise FirebaseDynamicLink::QuotaExceeded, 'Request limit has been reached' + raise FirebaseDynamicLink::QuotaExceeded, "Request limit has been reached" end end end diff --git a/lib/firebase_dynamic_link/version.rb b/lib/firebase_dynamic_link/version.rb index 512a4eb..ab4d0c1 100644 --- a/lib/firebase_dynamic_link/version.rb +++ b/lib/firebase_dynamic_link/version.rb @@ -1,5 +1,6 @@ +# typed: strict # frozen_string_literal: true module FirebaseDynamicLink - VERSION = '2.0.1' + VERSION = "2.0.1" end diff --git a/report/IDE-config.txt b/report/IDE-config.txt new file mode 100644 index 0000000..90f0668 --- /dev/null +++ b/report/IDE-config.txt @@ -0,0 +1,27 @@ +MegaLinter can help you to define the same linter configuration locally + +INSTRUCTIONS + +- Copy the content of IDE-config folder at the root of your repository +- if you are using Visual Studio Code, just reopen your project after the copy, and you will be prompted to install recommended extensions +- If not, you can install extensions manually using the following links. + +IDE EXTENSIONS APPLICABLE TO YOUR PROJECT + +rubocop (RUBY) + - atom: + - linter-rubocop: https://github.com/AtomLinter/linter-rubocop + - brackets: + - brackets-rubocop: https://github.com/smockle-archive/brackets-rubocop + - emacs: + - rubocop-emacs: https://github.com/rubocop-hq/rubocop-emacs + - flycheck: https://github.com/flycheck/flycheck + - idea: + - RubyMine: https://www.jetbrains.com/help/idea/2017.1/rubocop.html + - sublime: + - sublime_rubocop: https://github.com/pderichs/sublime_rubocop + - vim: + - vim-rubocop: https://github.com/ngmy/vim-rubocop + - ale: https://github.com/w0rp/ale + - vscode: + - VsCode Ruby Extension: https://marketplace.visualstudio.com/items?itemName=rebornix.Ruby diff --git a/report/IDE-config/.ruby-lint.yml b/report/IDE-config/.ruby-lint.yml new file mode 100644 index 0000000..b9c4d88 --- /dev/null +++ b/report/IDE-config/.ruby-lint.yml @@ -0,0 +1,8 @@ +--- +####################### +# Rubocop Config file # +####################### + +inherit_gem: + rubocop-github: + - config/default.yml diff --git a/report/IDE-config/.vscode/extensions.json b/report/IDE-config/.vscode/extensions.json new file mode 100644 index 0000000..d5a09b8 --- /dev/null +++ b/report/IDE-config/.vscode/extensions.json @@ -0,0 +1,5 @@ +{ + "recommendations": [ + "rebornix.Ruby" + ] +} \ No newline at end of file diff --git a/report/linters_logs/SUCCESS-RUBY_RUBOCOP.log b/report/linters_logs/SUCCESS-RUBY_RUBOCOP.log new file mode 100644 index 0000000..96da2af --- /dev/null +++ b/report/linters_logs/SUCCESS-RUBY_RUBOCOP.log @@ -0,0 +1,14 @@ +Results of rubocop linter (version 1.29.1) +See documentation on https://megalinter.github.io/descriptors/ruby_rubocop/ +----------------------------------------------- + +✅ [SUCCESS] lib/firebase_dynamic_link.rb - FIXED +✅ [SUCCESS] lib/firebase_dynamic_link/client.rb - FIXED +✅ [SUCCESS] lib/firebase_dynamic_link/connection.rb - FIXED +✅ [SUCCESS] lib/firebase_dynamic_link/link_renderer.rb - FIXED +✅ [SUCCESS] lib/firebase_dynamic_link/version.rb - FIXED +✅ [SUCCESS] spec/client_spec.rb - FIXED +✅ [SUCCESS] spec/connection_spec.rb - FIXED +✅ [SUCCESS] spec/firebase_dynamic_link_spec.rb - FIXED +✅ [SUCCESS] spec/link_renderer_spec.rb - FIXED +✅ [SUCCESS] spec/spec_helper.rb - FIXED diff --git a/report/linters_logs/SUCCESS-SPELL_MISSPELL.log b/report/linters_logs/SUCCESS-SPELL_MISSPELL.log new file mode 100644 index 0000000..c083f24 --- /dev/null +++ b/report/linters_logs/SUCCESS-SPELL_MISSPELL.log @@ -0,0 +1,5 @@ +Results of misspell linter (version 0.3.4) +See documentation on https://megalinter.github.io/descriptors/spell_misspell/ +----------------------------------------------- + +✅ [SUCCESS] for workspace /github/workspace diff --git a/report/mega-linter.log b/report/mega-linter.log new file mode 100644 index 0000000..e36ca01 --- /dev/null +++ b/report/mega-linter.log @@ -0,0 +1,145 @@ +---------------------------------------------------------------------------------------------------- +-------------------------------------------- MegaLinter -------------------------------------------- +---------------------------------------------------------------------------------------------------- + - Image Creation Date: 2022-05-15T19:58:30Z + - Image Revision: 7908c4d34 + - Image Version: v5 +---------------------------------------------------------------------------------------------------- +The MegaLinter documentation can be found at: + - https://megalinter.github.io +---------------------------------------------------------------------------------------------------- +GITHUB_REPOSITORY: saiqulhaq/firebase_dynamic_link +GITHUB_REF: refs/pull/30/merge +GITHUB_RUN_ID: 2418505211 + + +RST_RSTFMT has been temporary disabled in MegaLinter, please use a previous MegaLinter version or wait for the next one ! +Skipped linters: ACTION_ACTIONLINT, ANSIBLE_ANSIBLE_LINT, ARM_ARM_TTK, BASH_EXEC, BASH_SHELLCHECK, BASH_SHFMT, CLOJURE_CLJ_KONDO, CLOUDFORMATION_CFN_LINT, COFFEE_COFFEELINT, COPYPASTE_JSCPD, CPP_CPPLINT, CREDENTIALS_SECRETLINT, CSHARP_DOTNET_FORMAT, CSS_SCSS_LINT, CSS_STYLELINT, C_CPPLINT, DART_DARTANALYZER, DOCKERFILE_DOCKERFILELINT, DOCKERFILE_HADOLINT, EDITORCONFIG_EDITORCONFIG_CHECKER, ENV_DOTENV_LINTER, GHERKIN_GHERKIN_LINT, GIT_GIT_DIFF, GO_GOLANGCI_LINT, GO_REVIVE, GRAPHQL_GRAPHQL_SCHEMA_LINTER, GROOVY_NPM_GROOVY_LINT, HTML_HTMLHINT, JAVASCRIPT_ES, JAVASCRIPT_PRETTIER, JAVASCRIPT_STANDARD, JAVA_CHECKSTYLE, JSON_ESLINT_PLUGIN_JSONC, JSON_JSONLINT, JSON_PRETTIER, JSON_V8R, JSX_ESLINT, KOTLIN_KTLINT, KUBERNETES_KUBECONFORM, KUBERNETES_KUBEVAL, LATEX_CHKTEX, LUA_LUACHECK, MARKDOWN_MARKDOWN_LINK_CHECK, MARKDOWN_MARKDOWN_TABLE_FORMATTER, MARKDOWN_REMARK_LINT, OPENAPI_SPECTRAL, PERL_PERLCRITIC, PHP_BUILTIN, PHP_PHPCS, PHP_PHPLINT, PHP_PHPSTAN, PHP_PSALM, POWERSHELL_POWERSHELL, PROTOBUF_PROTOLINT, PUPPET_PUPPET_LINT, PYTHON_BANDIT, PYTHON_BLACK, PYTHON_FLAKE8, PYTHON_ISORT, PYTHON_MYPY, PYTHON_PYLINT, RAKU_RAKU, RST_RSTCHECK, RST_RSTFMT, RST_RST_LINT, RUST_CLIPPY, R_LINTR, SALESFORCE_SFDX_SCANNER_APEX, SALESFORCE_SFDX_SCANNER_AURA, SALESFORCE_SFDX_SCANNER_LWC, SCALA_SCALAFIX, SNAKEMAKE_LINT, SNAKEMAKE_SNAKEFMT, SPELL_CSPELL, SQL_SQLFLUFF, SQL_SQL_LINT, SQL_TSQLLINT, SWIFT_SWIFTLINT, TEKTON_TEKTON_LINT, TERRAFORM_CHECKOV, TERRAFORM_KICS, TERRAFORM_TERRAFORM_FMT, TERRAFORM_TERRAGRUNT, TERRAFORM_TERRASCAN, TERRAFORM_TFLINT, TSX_ESLINT, TYPESCRIPT_ES, TYPESCRIPT_PRETTIER, TYPESCRIPT_STANDARD, VBDOTNET_DOTNET_FORMAT, XML_XMLLINT, YAML_PRETTIER, YAML_V8R, YAML_YAMLLINT +To receive reports as email, please set variable EMAIL_REPORTER_EMAIL +Listing updated files in [/github/workspace] using git diff. +Modified files: +.github/workflows/mega-linter.yml +.mega-linter.yml +firebase_dynamic_link.gemspec +lib/firebase_dynamic_link.rb +lib/firebase_dynamic_link/client.rb +lib/firebase_dynamic_link/connection.rb +lib/firebase_dynamic_link/link_renderer.rb +lib/firebase_dynamic_link/version.rb +sorbet/config +sorbet/rbi/firebase_dynamic_link.rbi +sorbet/rbi/gems/appraisal.rbi +sorbet/rbi/gems/ast.rbi +sorbet/rbi/gems/bootsnap.rbi +sorbet/rbi/gems/bundler-audit.rbi +sorbet/rbi/gems/case_transform2.rbi +sorbet/rbi/gems/coderay.rbi +sorbet/rbi/gems/commander.rbi +sorbet/rbi/gems/concurrent-ruby.rbi +sorbet/rbi/gems/docile.rbi +sorbet/rbi/gems/dotenv.rbi +sorbet/rbi/gems/dry-configurable.rbi +sorbet/rbi/gems/dry-core.rbi +sorbet/rbi/gems/faraday-net_http.rbi +sorbet/rbi/gems/faraday.rbi +sorbet/rbi/gems/firebase_dynamic_link.rbi +sorbet/rbi/gems/highline.rbi +sorbet/rbi/gems/method_source.rbi +sorbet/rbi/gems/msgpack.rbi +sorbet/rbi/gems/parallel.rbi +sorbet/rbi/gems/parlour.rbi +sorbet/rbi/gems/parser.rbi +sorbet/rbi/gems/pry.rbi +sorbet/rbi/gems/rainbow.rbi +sorbet/rbi/gems/rake.rbi +sorbet/rbi/gems/regexp_parser.rbi +sorbet/rbi/gems/rexml.rbi +sorbet/rbi/gems/rspec-core.rbi +sorbet/rbi/gems/rspec-expectations.rbi +sorbet/rbi/gems/rspec-mocks.rbi +sorbet/rbi/gems/rspec-support.rbi +sorbet/rbi/gems/rspec.rbi +sorbet/rbi/gems/rubocop-ast.rbi +sorbet/rbi/gems/rubocop-rspec.rbi +sorbet/rbi/gems/rubocop.rbi +sorbet/rbi/gems/ruby-progressbar.rbi +sorbet/rbi/gems/simplecov-html.rbi +sorbet/rbi/gems/simplecov.rbi +sorbet/rbi/gems/sord.rbi +sorbet/rbi/gems/thor.rbi +sorbet/rbi/gems/unicode-display_width.rbi +sorbet/rbi/gems/vcr.rbi +sorbet/rbi/gems/yard.rbi +sorbet/rbi/hidden-definitions/errors.txt +sorbet/rbi/hidden-definitions/hidden.rbi +sorbet/rbi/sorbet-typed/lib/bundler-audit/all/bundler-audit.rbi +sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi +sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi +sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi +sorbet/rbi/sorbet-typed/lib/thor/all/thor.rbi +sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi +spec/client_spec.rb +spec/connection_spec.rb +spec/firebase_dynamic_link_spec.rb +spec/link_renderer_spec.rb +spec/spec_helper.rb +- File extensions: .md, .rb +- Excluding .gitignored files [0]: +Kept [10] files on [67] found files + ++----MATCHING LINTERS---+----------+----------------+------------+ +| Descriptor | Linter | Criteria | Matching files | Format/Fix | ++------------+----------+----------+----------------+------------+ +| RUBY | rubocop | .rb | 10 | yes | +| SPELL | misspell | | 10 | yes | ++------------+----------+----------+----------------+------------+ + + +### Processed [SPELL] files +- Using [misspell v0.3.4] https://megalinter.github.io/v5/descriptors/spell_misspell +- MegaLinter key: [SPELL_MISSPELL] +- Rules config: identified by [misspell] +[misspell] lib/firebase_dynamic_link.rb +[misspell] lib/firebase_dynamic_link/client.rb +[misspell] lib/firebase_dynamic_link/connection.rb +[misspell] lib/firebase_dynamic_link/link_renderer.rb - FIXED +[misspell] lib/firebase_dynamic_link/version.rb +[misspell] spec/client_spec.rb +[misspell] spec/connection_spec.rb +[misspell] spec/firebase_dynamic_link_spec.rb +[misspell] spec/link_renderer_spec.rb +[misspell] spec/spec_helper.rb +✅ Linted [SPELL] files with [misspell] successfully - (0.07s) +[Text Reporter] Generated TEXT report: /github/workspace/report/linters_logs/SUCCESS-SPELL_MISSPELL.log + +### Processed [RUBY] files +- Using [rubocop v1.29.1] https://megalinter.github.io/v5/descriptors/ruby_rubocop +- MegaLinter key: [RUBY_RUBOCOP] +- Rules config: [.ruby-lint.yml] +[rubocop] lib/firebase_dynamic_link.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] lib/firebase_dynamic_link/client.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] lib/firebase_dynamic_link/connection.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] lib/firebase_dynamic_link/link_renderer.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] lib/firebase_dynamic_link/version.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] spec/client_spec.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] spec/connection_spec.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] spec/firebase_dynamic_link_spec.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] spec/link_renderer_spec.rb - SUCCESS - 0 error(s) - FIXED +[rubocop] spec/spec_helper.rb - SUCCESS - 0 error(s) - FIXED +✅ Linted [RUBY] files with [rubocop] successfully - (17.37s) +[Text Reporter] Generated TEXT report: /github/workspace/report/linters_logs/SUCCESS-RUBY_RUBOCOP.log + ++----SUMMARY-+----------+---------------+-------+-------+--------+--------------+ +| Descriptor | Linter | Mode | Files | Fixed | Errors | Elapsed time | ++------------+----------+---------------+-------+-------+--------+--------------+ +| ✅ RUBY | rubocop | file | 10 | 10 | 0 | 17.37s | +| ✅ SPELL | misspell | list_of_files | 10 | 1 | 0 | 0.07s | ++------------+----------+---------------+-------+-------+--------+--------------+ + +Identified PR#30 from environment +[GitHub Comment Reporter] Posted summary as comment on saiqulhaq/firebase_dynamic_link #PR30 +[Updated Sources Reporter] copied 10 fixed source files in folder /github/workspace/report/updated_sources. +Download it from artifacts then copy-paste it in your local repo to apply linters updates +✅ Successfully linted all files without errors diff --git a/report/updated_sources/lib/firebase_dynamic_link.rb b/report/updated_sources/lib/firebase_dynamic_link.rb new file mode 100644 index 0000000..50704fa --- /dev/null +++ b/report/updated_sources/lib/firebase_dynamic_link.rb @@ -0,0 +1,131 @@ +# typed: true +# frozen_string_literal: true + +require "dry-configurable" +require "dry/configurable/version" +require "faraday" +require "faraday/net_http" if Faraday::VERSION.to_f >= 2.0 +require "firebase_dynamic_link/client" +require "firebase_dynamic_link/link_renderer" +require "firebase_dynamic_link/version" + +module FirebaseDynamicLink + extend Dry::Configurable + + USE_FARADAY_2 = Faraday::VERSION.to_i == 2 + USE_DRY_CONFIGURABLE_0_13 = Dry::Configurable::VERSION.to_f >= 0.13 + + # called when invalid configuration given + class InvalidConfig < StandardError; end + + # called when HTTP request failed + class ConnectionError < StandardError; end + + # called when Firebase says that no more quota + class QuotaExceeded < StandardError; end + + if FirebaseDynamicLink::USE_FARADAY_2 && Faraday.default_adapter == :test + Faraday.default_adapter = :net_http # default adapter included in this gem + end + + # @!group Configuration + # @!method adapter + # @!scope class + # Selected Faraday HTTP adapter + # @!method adapter=(adapter_key) + # @!scope class + # Set Faraday HTTP adapter + # @param adapter_key [Symbol] + # @example + # FirebaseDynamicLink.adapter = :patron + # FirebaseDynamicLink.adapter = :httpclient + # FirebaseDynamicLink.adapter = :net_http_persistent + # @see https://github.com/lostisland/faraday/tree/master/test/adapters + # @since 0.1.0 + if USE_DRY_CONFIGURABLE_0_13 + setting :adapter, default: Faraday.default_adapter + else + setting :adapter, Faraday.default_adapter + end + + # @!method api_key + # @!scope class + # Given api key + # @!method api_key=(key) + # @!scope class + # Set api key + # @param key [String] + # @since 0.1.0 + setting :api_key + + # @!method timeout + # Timeout default setting is 3 seconds + # @!scope class + # @!method timeout=(seconds) + # @!scope class + # @param seconds [Integer] + # @since 0.1.0 + # @!scope class + if USE_DRY_CONFIGURABLE_0_13 + setting :timeout, default: 3 + else + setting :timeout, 3 + end + + # @!method open_timeout + # @!scope class + # Open timeout default setting is 3 seconds + # @!method open_timeout=(seconds) + # @!scope class + # @param seconds [Integer] + # @since 0.1.0 + # @!scope class + if USE_DRY_CONFIGURABLE_0_13 + setting :open_timeout, default: 3 + else + setting :open_timeout, 3 + end + + # @!method dynamic_link_domain + # @!scope class + # Firebase dynamic link domain + # @!method dynamic_link_domain=(domain) + # @!scope class + # @param domain [String] + # @since 1.0.0 + # @!scope class + setting(:dynamic_link_domain) + + # @!method suffix_option + # @!scope class + # Firebase suffix option setting, default is UNGUESSABLE + # @!method suffix_option=(suffix) + # @!scope class + # @raise [FirebaseDynamicLink::InvalidConfig] if value is not one of SHORT and UNGUESSABLE + # @param suffix [String] + # @since 1.0.0 + # @!scope class + if USE_DRY_CONFIGURABLE_0_13 + setting(:suffix_option, default: "UNGUESSABLE", constructor: lambda { |value| + if %w[SHORT + UNGUESSABLE].include?(value) + value + else + raise(FirebaseDynamicLink::InvalidConfig, + "default suffix option config is not valid") + end + }) + else + setting(:suffix_option, "UNGUESSABLE") do |value| + if %w[SHORT + UNGUESSABLE].include?(value) + value + else + raise(FirebaseDynamicLink::InvalidConfig, + "default suffix option config is not valid") + end + end + + end + # @!endgroup +end diff --git a/report/updated_sources/lib/firebase_dynamic_link/client.rb b/report/updated_sources/lib/firebase_dynamic_link/client.rb new file mode 100644 index 0000000..93b7fa3 --- /dev/null +++ b/report/updated_sources/lib/firebase_dynamic_link/client.rb @@ -0,0 +1,165 @@ +# typed: true +# frozen_string_literal: true + +require "uri" +require "firebase_dynamic_link/connection" +require "firebase_dynamic_link/link_renderer" +require "case_transform2" + +module FirebaseDynamicLink + # Main class that responsible to shorten link or parameters + class Client + extend Forwardable + + def initialize(api_key: config.api_key) + @link_renderer = FirebaseDynamicLink::LinkRenderer.new + short_links_url = end_point(api_key) + @connection = FirebaseDynamicLink::Connection.new(short_links_url) + end + + # @param link [String] required + # @param options [Hash] + # * :timeout optional, default is FirebaseDynamicLink.config.timout + # * :open_timeout [Integer] optional, default is FirebaseDynamicLink.config.open_timout + # * :suffix_option [String] optional, default is FirebaseDynamicLink.config.suffix_option + # * :dynamic_link_domain [String] optional, default is FirebaseDynamicLink.config.dynamic_link_domain + # @return [Hash{Symbol=>String}] + # @see FirebaseDynamicLink::LinkRenderer#render LinkRenderer#render for returned Hash + def shorten_link(link, options = {}) + connection.timeout = options[:timeout] if options.key?(:timeout) + connection.open_timeout = options[:open_timeout] if options.key?(:open_timeout) + + suffix_option = options[:suffix_option] if options.key?(:suffix_option) + + params = CaseTransform2.camel_lower(long_dynamic_link: build_link(link, options), + suffix: { + option: suffix_option || config.suffix_option + }) + response = connection.post(nil, params.to_json) + link_renderer.render(response) + rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e + raise FirebaseDynamicLink::ConnectionError, e.message + end + + # @param params [Hash] + # * link [String] + # * android_info [Hash] + # * android_package_name [String] + # * android_fallback_link [String] + # * android_min_package_version_code [String] + # * android_link [String] + # * ios_info [Hash] + # * ios_bundle_id [String] + # * ios_fallback_link [String] + # * ios_custom_scheme [String] + # * ios_ipad_fallback_link [String] + # * ios_ipad_bundle_id [String] + # * ios_app_store_id [String] + # * navigation_info [Hash] + # * enable_forced_redirect [Boolean] + # * analytics_info [Hash] + # * google_play_analytics [Hash] + # * utm_source [String] + # * utm_medium [String] + # * utm_campaign [String] + # * utm_term [String] + # * utm_content [String] + # * gclid [String] + # * itunes_connect_analytics [Hash] + # * at [String] + # * ct [String] + # * mt [String] + # * pt [String] + # * social_meta_tag_info [Hash] + # * social_title [String] + # * social_description [String] + # * social_image_link [String] + # @example + # options = { + # suffix_option: "SHORT", + # dynamic_link_domain: 'domain' # optional + # } + # + # parameters = { + # link: link, + # android_info: { + # android_package_name: string, + # android_fallback_link: string, + # android_min_package_version_code: string, + # android_link: string + # }, + # ios_info: { + # ios_bundle_id: string, + # ios_fallback_link: string, + # ios_custom_scheme: string, + # ios_ipad_fallback_link: string, + # ios_ipad_bundle_id: string, + # ios_app_store_id: string + # }, + # navigation_info: { + # enable_forced_redirect: boolean, + # }, + # analytics_info: { + # google_play_analytics: { + # utm_source: string, + # utm_medium: string, + # utm_campaign: string, + # utm_term: string, + # utm_content: string, + # gclid: string + # }, + # itunes_connect_analytics: { + # at: string, + # ct: string, + # mt: string, + # pt: string + # } + # }, + # social_meta_tag_info: { + # social_title: string, + # social_description: string, + # social_image_link: string + # } + # } + # result = instance.shorten_parameters(parameters, options) + # @return [Hash{Symbol=>String}] + # @see FirebaseDynamicLink::LinkRenderer#render LinkRenderer#render for returned Hash + def shorten_parameters(params, options = {}) + connection.timeout = options[:timeout] if options.key?(:timeout) + connection.open_timeout = options[:open_timeout] if options.key?(:open_timeout) + + suffix_option = options[:suffix_option] if options.key?(:suffix_option) + + dynamic_link_domain = options.delete(:dynamic_link_domain) + dynamic_link_domain ||= config.dynamic_link_domain || raise(FirebaseDynamicLink::InvalidConfig, + "Dynamic link domain is empty") + + params = CaseTransform2.camel_lower(dynamic_link_info: params.merge(domainUriPrefix: dynamic_link_domain), + suffix: { + option: suffix_option || config.suffix_option + }) + response = connection.post(nil, params.to_json) + link_renderer.render(response) + rescue Faraday::ConnectionFailed, Faraday::TimeoutError => e + raise FirebaseDynamicLink::ConnectionError, e.message + end + + private + + def_delegators :@link_renderer, :render_success, :raise_error + def_delegators :FirebaseDynamicLink, :config + + attr_reader :link_renderer, :connection + + def build_link(link, options) + dynamic_link_domain = options.delete(:dynamic_link_domain) + dynamic_link_domain ||= config.dynamic_link_domain || raise(FirebaseDynamicLink::InvalidConfig, + "Dynamic link domain is empty") + "#{dynamic_link_domain}?link=#{link}" + end + + def end_point(api_key) + "https://firebasedynamiclinks.googleapis.com/v1/shortLinks?key=#{api_key}" + end + end +end diff --git a/report/updated_sources/lib/firebase_dynamic_link/connection.rb b/report/updated_sources/lib/firebase_dynamic_link/connection.rb new file mode 100644 index 0000000..fc225b8 --- /dev/null +++ b/report/updated_sources/lib/firebase_dynamic_link/connection.rb @@ -0,0 +1,45 @@ +# typed: true +# frozen_string_literal: true + +module FirebaseDynamicLink + # Responsible to do HTTP request + class Connection + extend Forwardable + + # @!method post + # see Faraday::Connection#post + def_delegators :client, :post + + def initialize(end_point) + @client = Faraday::Connection.new(url: end_point, + headers: { "Content-Type" => "application/json" }) + + client.options.timeout = FirebaseDynamicLink.config.timeout + client.options.open_timeout = FirebaseDynamicLink.config.open_timeout + end + + # @see Faraday.timeout= + def timeout=(time) + client.options.timeout = time + end + + # @see Faraday.timeout + def timeout + client.options.timeout + end + + # @see Faraday.open_timeout= + def open_timeout=(time) + client.options.open_timeout = time + end + + # @see Faraday.open_timeout + def open_timeout + client.options.open_timeout + end + + private + + attr_reader :client + end +end diff --git a/report/updated_sources/lib/firebase_dynamic_link/link_renderer.rb b/report/updated_sources/lib/firebase_dynamic_link/link_renderer.rb new file mode 100644 index 0000000..63a6d30 --- /dev/null +++ b/report/updated_sources/lib/firebase_dynamic_link/link_renderer.rb @@ -0,0 +1,55 @@ +# typed: true +# frozen_string_literal: true + +module FirebaseDynamicLink + # Responsible to formatting output of Client#shorten_link + class LinkRenderer + # @param response [Faraday::Connection] http response + # @return [Hash + # @example + # { + # :link => short link result + # :preview_link => preview of short link result + # :warning => warning message by Firebase if present + # } + # @raise FirebaseDynamicLink::ConnectionError if there is something wrong with Faraday request + # @raise FirebaseDynamicLink::QuotaExceeded if request reached Google Firebase quota + def render(response) + if response.status.between?(200, 299) + render_success(response) + elsif response.status == 429 + raise_limit_has_reached + else + raise_error(response) + end + end + + private + + def render_success(response) + body = JSON.parse(response.body) + return raise_error(response) if body.key?("error") + + { + link: body["shortLink"], + preview_link: body["previewLink"], + warning: body["warning"] + } + end + + def raise_error(response) + reason = response.reason_phrase.to_s if response.respond_to?(:reason_phrase) + message = begin + body = JSON.parse(response.body) + body["error"]["message"] + rescue JSON::ParserError, NoMethodError + response.body + end + raise FirebaseDynamicLink::ConnectionError, [reason, message].compact.join(": ") + end + + def raise_limit_has_reached + raise FirebaseDynamicLink::QuotaExceeded, "Request limit has been reached" + end + end +end diff --git a/report/updated_sources/lib/firebase_dynamic_link/version.rb b/report/updated_sources/lib/firebase_dynamic_link/version.rb new file mode 100644 index 0000000..ab4d0c1 --- /dev/null +++ b/report/updated_sources/lib/firebase_dynamic_link/version.rb @@ -0,0 +1,6 @@ +# typed: strict +# frozen_string_literal: true + +module FirebaseDynamicLink + VERSION = "2.0.1" +end diff --git a/report/updated_sources/spec/client_spec.rb b/report/updated_sources/spec/client_spec.rb new file mode 100644 index 0000000..e26a4db --- /dev/null +++ b/report/updated_sources/spec/client_spec.rb @@ -0,0 +1,202 @@ +# typed: false +# frozen_string_literal: true + +RSpec.describe FirebaseDynamicLink::Client do + before(:all) { FirebaseDynamicLink.reset_config } + + let(:connection_failed_class) do + Class.new do + def post(*) + raise Faraday::ConnectionFailed, "test" + end + end + end + let(:timout_error_class) do + Class.new do + def post(*) + raise Faraday::TimeoutError, "test" + end + end + end + + before do + FirebaseDynamicLink.configure do |config| + config.api_key = ENV["API_KEY"] + config.dynamic_link_domain = ENV["DYNAMIC_LINK_DOMAIN"] + end + end + + describe "#shorten_link" do + shared_examples "short link created correctly" do |api_key_location| + context "when faraday default adapter is not defined" do + it "raises error" do + if FirebaseDynamicLink::USE_FARADAY_2 + Faraday.default_adapter = nil + + link = "http://saiqulhaq.com" + options = { suffix_option: "SHORT" } + expect { + subject.shorten_link(link, options) + }.to raise_error + else + expect(true).to be_truthy + end + end + end + + context "when faraday default adapter is defined" do + before do + Faraday.default_adapter = :net_http if FirebaseDynamicLink::USE_FARADAY_2 + end + + it "shorten link correctly" do + link = "http://saiqulhaq.com" + VCR.use_cassette("shorten_link-SHORT-#{ENV['BUNDLE_GEMFILE']}-#{api_key_location}") do + options = { suffix_option: "SHORT" } + result = subject.shorten_link(link, options) + expect(result[:link]).not_to eq("") + expect(result[:link]).not_to eq(link) + end + + VCR.use_cassette("shorten_link-UNGUESSABLE-#{ENV['BUNDLE_GEMFILE']}-#{api_key_location}") do + options = { suffix_option: "UNGUESSABLE", timout: 5 } + result = subject.shorten_link(link, options) + expect(result[:link]).not_to eq("") + expect(result[:link]).not_to eq(link) + end + end + end + end + + include_examples "short link created correctly", :global + + context "with api_key provided to constructor" do + subject { described_class.new(api_key: ENV["API_KEY"]) } + + before do + FirebaseDynamicLink.reset_config + FirebaseDynamicLink.configure do |config| + config.api_key = "i am not valid api key" + config.dynamic_link_domain = ENV["DYNAMIC_LINK_DOMAIN"] + end + end + + include_examples "short link created correctly", :local + end + + it "raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised" do + allow_any_instance_of(described_class).to receive(:connection).and_return(connection_failed_class.new) + expect do + subject.shorten_link("http://saiqulhaq.com") + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + + it "raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised" do + allow_any_instance_of(described_class).to receive(:connection).and_return(timout_error_class.new) + expect do + subject.shorten_link("http://saiqulhaq.com") + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + end + + describe "#shorten_parameters" do + let(:link) { "http://saiqulhaq.com/asldkj" } + let(:parameters) do + string = "foo" + { + link: link, + android_info: { + android_package_name: "com.foo.name" + }, + ios_info: { + ios_bundle_id: string, + ios_fallback_link: string, + ios_custom_scheme: string, + ios_ipad_fallback_link: string, + ios_ipad_bundle_id: string, + ios_app_store_id: string + }, + navigation_info: { + enable_forced_redirect: [true, false].sample + }, + analytics_info: { + google_play_analytics: { + utm_source: "custom" + }, + itunes_connect_analytics: { + at: string + } + }, + social_meta_tag_info: { + social_title: string, + social_description: string, + social_image_link: string + } + } + end + + context "when faraday default adapter is not defined" do + it "raises error" do + if FirebaseDynamicLink::USE_FARADAY_2 + Faraday.default_adapter = nil + + link = "http://saiqulhaq.com" + options = { suffix_option: "SHORT" } + expect { + subject.shorten_parameters(parameters, options) + }.to raise_error + else + expect(true).to be_truthy + end + end + end + + context "when faraday default adapter is defined" do + before do + Faraday.default_adapter = :net_http if FirebaseDynamicLink::USE_FARADAY_2 + end + + it "shorten link correctly" do + VCR.use_cassette("shorten_parameters-SHORT-#{ENV['BUNDLE_GEMFILE']}") do + options = { + suffix_option: "SHORT" + # dynamic_link_domain: 'foo' # optional + } + + expect do + result = subject.shorten_parameters(parameters, options) + expect(result[:link]).not_to eq("") + expect(result[:link]).not_to eq(link) + end.not_to raise_error + end + + VCR.use_cassette("shorten_parameters-UNGUESSABLE-#{ENV['BUNDLE_GEMFILE']}") do + options = { + suffix_option: "UNGUESSABLE" + # dynamic_link_domain: 'foo' # optional + } + + expect do + result = subject.shorten_parameters(parameters, options) + expect(result[:link]).not_to eq("") + expect(result[:link]).not_to eq(link) + end.not_to raise_error + end + end + + it "raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised" do + allow_any_instance_of(described_class).to receive(:connection).and_return(connection_failed_class.new) + expect do + subject.shorten_parameters(parameters) + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + + it "raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised" do + allow_any_instance_of(described_class).to receive(:connection).and_return(timout_error_class.new) + expect do + subject.shorten_parameters(parameters) + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + end + end +end diff --git a/report/updated_sources/spec/connection_spec.rb b/report/updated_sources/spec/connection_spec.rb new file mode 100644 index 0000000..4af4a4f --- /dev/null +++ b/report/updated_sources/spec/connection_spec.rb @@ -0,0 +1,32 @@ +# typed: false +# frozen_string_literal: true + +RSpec.describe FirebaseDynamicLink::Connection do + subject { instance } + + let(:instance) { described_class.new("http://saiqulhaq.com") } + + describe "#timeout" do + it "uses default config timeout as default" do + expect(instance.timeout).to eq(FirebaseDynamicLink.config.timeout) + end + + it "configurable" do + instance.timeout = 10 + expect(instance.timeout).to eq(10) + end + end + + describe "#open_timeout" do + it "uses default config open_timeout as default" do + expect(instance.open_timeout).to eq(FirebaseDynamicLink.config.open_timeout) + end + + it "configurable" do + instance.open_timeout = 8 + expect(instance.open_timeout).to eq(8) + end + end + + it { is_expected.to respond_to(:post) } +end diff --git a/report/updated_sources/spec/firebase_dynamic_link_spec.rb b/report/updated_sources/spec/firebase_dynamic_link_spec.rb new file mode 100644 index 0000000..dd93759 --- /dev/null +++ b/report/updated_sources/spec/firebase_dynamic_link_spec.rb @@ -0,0 +1,68 @@ +# typed: false +# frozen_string_literal: true + +require "faraday" + +RSpec.describe FirebaseDynamicLink do + before(:all) { described_class.reset_config } + + it "has a version number" do + expect(FirebaseDynamicLink::VERSION).to eq("2.0.1") + end + + describe ".config" do + subject { described_class.config } + + { + adapter: { + default: Faraday.default_adapter, + valid_value: :net_http + }, + api_key: { + default: nil, + valid_value: "foobar" + }, + dynamic_link_domain: { + default: nil, + valid_value: "http://asd.com/asd" + }, + timeout: { + default: 3, + valid_value: 2 + }, + open_timeout: { + default: 3, + valid_value: 1 + }, + suffix_option: { + default: "UNGUESSABLE", + valid_value: "SHORT" + } + }.each do |method, meta| + describe ".#{method}" do + it "default value is #{meta[:default].nil? ? 'nil' : meta[:default]}" do + if subject.respond_to? :values + expect(subject.values[method]).to eq(meta[:default]) + else + expect(subject.send(method)).to eq(meta[:default]) + end + end + + it "is writable" do + subject.send("#{method}=".to_sym, meta[:valid_value]) + if subject.respond_to? :values + expect(subject.values[method]).to eq(meta[:valid_value]) + else + expect(subject.send(method.to_sym)).to eq(meta[:valid_value]) + end + end + end + end + + describe "suffix_option=" do + it "raises FirebaseDynamicLink::InvalidConfig if given parameter is not valid" do + expect { subject.suffix_option = "FOO" }.to raise_error(FirebaseDynamicLink::InvalidConfig) + end + end + end +end diff --git a/report/updated_sources/spec/link_renderer_spec.rb b/report/updated_sources/spec/link_renderer_spec.rb new file mode 100644 index 0000000..8b299ca --- /dev/null +++ b/report/updated_sources/spec/link_renderer_spec.rb @@ -0,0 +1,69 @@ +# typed: false +# frozen_string_literal: true + +RSpec.describe FirebaseDynamicLink::LinkRenderer do + let(:success_response) do + OpenStruct.new(status: 200, body: { + shortLink: "http://link", + previewLink: "http://xxx.goo.gl/foo?preview", + warning: [{ + "warningCode" => "UNRECOGNIZED_PARAM", + "warningMessage" => "..." + }] + }.to_json) + end + + let(:fail_response) do + OpenStruct.new(status: [422, 500].sample, body: { + error: { + message: "xxx" + } + }.to_json) + end + + let(:instance) { described_class.new } + + describe "#render" do + context "when response is success" do + it "parsed output correctly" do + output = instance.render(success_response) + expect(output).to have_key(:link) + expect(output).to have_key(:preview_link) + expect(output).to have_key(:warning) + expect(output[:link]).to eq("http://link") + end + + it "raise error if response body has error key" do + success_response.body = JSON.parse(success_response.body).merge(error: "foo").to_json + expect do + instance.render(success_response) + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + end + + context "when response is fail" do + it "raises error" do + expect do + instance.render(fail_response) + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + + it "render response.body if response.body.error.message is not exist" do + fail_response.body = "foobar" + expect do + instance.render(fail_response) + end.to raise_error(FirebaseDynamicLink::ConnectionError) + end + end + + context "when response.status is 429" do + it "raise FirebaseDynamicLink::QuotaExceeded" do + response = fail_response + response.status = 429 + expect do + instance.render(response) + end.to raise_error(FirebaseDynamicLink::QuotaExceeded) + end + end + end +end diff --git a/report/updated_sources/spec/spec_helper.rb b/report/updated_sources/spec/spec_helper.rb new file mode 100644 index 0000000..4977e92 --- /dev/null +++ b/report/updated_sources/spec/spec_helper.rb @@ -0,0 +1,65 @@ +# typed: false +# frozen_string_literal: true + +require "bundler/setup" +require "bootsnap" +require "faraday" + +enable_coverage = ENV.fetch("COVERAGE", 0).to_s == "1" + +Bootsnap.setup( + cache_dir: "tmp/cache", # Path to your cache + development_mode: true, # Current working environment, e.g. RACK_ENV, RAILS_ENV, etc + load_path_cache: true, # Optimize the LOAD_PATH with a cache + compile_cache_iseq: !enable_coverage, # Compile Ruby code into ISeq cache, breaks coverage reporting. + compile_cache_yaml: true # Compile YAML into a cache +) + +require "dotenv/load" + +if enable_coverage + require "simplecov" + SimpleCov.start +end + +require "firebase_dynamic_link" +require "vcr" + +begin + require "pry" +rescue LoadError +end + +require "dry/configurable/test_interface" + +begin + module FirebaseDynamicLink + enable_test_interface + end +rescue LoadError + module FirebaseDynamicLink + extend Dry::Configurable::TestInterface + end +end + +RSpec.configure do |config| + # Enable flags like --only-failures and --next-failure + config.example_status_persistence_file_path = ".rspec_status" + + # Disable RSpec exposing methods globally on `Module` and `main` + config.disable_monkey_patching! + + config.expect_with :rspec do |c| + c.syntax = :expect + end + + config.after(:each) do + Faraday.default_connection = nil + end +end + +VCR.configure do |config| + config.allow_http_connections_when_no_cassette = true + config.cassette_library_dir = "spec/fixtures/vcr_cassettes" + config.hook_into :faraday +end diff --git a/sorbet/config b/sorbet/config new file mode 100644 index 0000000..534118e --- /dev/null +++ b/sorbet/config @@ -0,0 +1,3 @@ +--dir +. +--ignore=/vendor/bundle diff --git a/sorbet/rbi/firebase_dynamic_link.rbi b/sorbet/rbi/firebase_dynamic_link.rbi new file mode 100644 index 0000000..af25afc --- /dev/null +++ b/sorbet/rbi/firebase_dynamic_link.rbi @@ -0,0 +1,216 @@ +# typed: strong +# typed: true +# frozen_string_literal: true +module FirebaseDynamicLink + extend Dry::Configurable + USE_FARADAY_2 = T.let(Faraday::VERSION.to_i == 2, T.untyped) + USE_DRY_CONFIGURABLE_0_13 = T.let(Dry::Configurable::VERSION.to_f >= 0.13, T.untyped) + VERSION = T.let('2.0.1', T.untyped) + + # sord omit - no YARD return type given, using untyped + # Given api key + sig { returns(T.untyped) } + def self.api_key; end + + # sord omit - no YARD return type given, using untyped + # Set api key + # + # _@param_ `key` + sig { params(key: String).returns(T.untyped) } + def self.api_key=(key); end + + # sord omit - no YARD return type given, using untyped + # Firebase dynamic link domain + sig { returns(T.untyped) } + def self.dynamic_link_domain; end + + # sord omit - no YARD return type given, using untyped + # _@param_ `domain` + sig { params(domain: String).returns(T.untyped) } + def self.dynamic_link_domain=(domain); end + + # called when invalid configuration given + class InvalidConfig < StandardError + end + + # called when HTTP request failed + class ConnectionError < StandardError + end + + # called when Firebase says that no more quota + class QuotaExceeded < StandardError + end + + # Main class that responsible to shorten link or parameters + class Client + extend Forwardable + + # sord omit - no YARD type given for "api_key:", using untyped + sig { params(api_key: T.untyped).void } + def initialize(api_key: config.api_key); end + + # _@param_ `link` — required + # + # _@param_ `options` — * :timeout optional, default is FirebaseDynamicLink.config.timout * :open_timeout [Integer] optional, default is FirebaseDynamicLink.config.open_timout * :suffix_option [String] optional, default is FirebaseDynamicLink.config.suffix_option * :dynamic_link_domain [String] optional, default is FirebaseDynamicLink.config.dynamic_link_domain + # + # _@see_ `FirebaseDynamicLink::LinkRenderer#render` — LinkRenderer#render for returned Hash + sig { params(link: String, options: T::Hash[T.untyped, T.untyped]).returns(T::Hash[Symbol, String]) } + def shorten_link(link, options = {}); end + + # sord omit - no YARD type given for "options", using untyped + # _@param_ `params` — * link [String] * android_info [Hash] * android_package_name [String] * android_fallback_link [String] * android_min_package_version_code [String] * android_link [String] * ios_info [Hash] * ios_bundle_id [String] * ios_fallback_link [String] * ios_custom_scheme [String] * ios_ipad_fallback_link [String] * ios_ipad_bundle_id [String] * ios_app_store_id [String] * navigation_info [Hash] * enable_forced_redirect [Boolean] * analytics_info [Hash] * google_play_analytics [Hash] * utm_source [String] * utm_medium [String] * utm_campaign [String] * utm_term [String] * utm_content [String] * gclid [String] * itunes_connect_analytics [Hash] * at [String] * ct [String] * mt [String] * pt [String] * social_meta_tag_info [Hash] * social_title [String] * social_description [String] * social_image_link [String] + # + # ```ruby + # options = { + # suffix_option: "SHORT", + # dynamic_link_domain: 'domain' # optional + # } + # + # parameters = { + # link: link, + # android_info: { + # android_package_name: string, + # android_fallback_link: string, + # android_min_package_version_code: string, + # android_link: string + # }, + # ios_info: { + # ios_bundle_id: string, + # ios_fallback_link: string, + # ios_custom_scheme: string, + # ios_ipad_fallback_link: string, + # ios_ipad_bundle_id: string, + # ios_app_store_id: string + # }, + # navigation_info: { + # enable_forced_redirect: boolean, + # }, + # analytics_info: { + # google_play_analytics: { + # utm_source: string, + # utm_medium: string, + # utm_campaign: string, + # utm_term: string, + # utm_content: string, + # gclid: string + # }, + # itunes_connect_analytics: { + # at: string, + # ct: string, + # mt: string, + # pt: string + # } + # }, + # social_meta_tag_info: { + # social_title: string, + # social_description: string, + # social_image_link: string + # } + # } + # result = instance.shorten_parameters(parameters, options) + # ``` + # + # _@see_ `FirebaseDynamicLink::LinkRenderer#render` — LinkRenderer#render for returned Hash + sig { params(params: T::Hash[T.untyped, T.untyped], options: T.untyped).returns(T::Hash[Symbol, String]) } + def shorten_parameters(params, options = {}); end + + # sord omit - no YARD type given for "link", using untyped + # sord omit - no YARD type given for "options", using untyped + # sord omit - no YARD return type given, using untyped + sig { params(link: T.untyped, options: T.untyped).returns(T.untyped) } + def build_link(link, options); end + + # sord omit - no YARD type given for "api_key", using untyped + # sord omit - no YARD return type given, using untyped + sig { params(api_key: T.untyped).returns(T.untyped) } + def end_point(api_key); end + + # sord omit - no YARD type given for :link_renderer, using untyped + # Returns the value of attribute link_renderer. + sig { returns(T.untyped) } + attr_reader :link_renderer + + # sord omit - no YARD type given for :connection, using untyped + # Returns the value of attribute connection. + sig { returns(T.untyped) } + attr_reader :connection + end + + # Responsible to do HTTP request + class Connection + extend Forwardable + + # sord omit - no YARD return type given, using untyped + # see Faraday::Connection#post + sig { returns(T.untyped) } + def post; end + + # sord omit - no YARD type given for "end_point", using untyped + sig { params(end_point: T.untyped).void } + def initialize(end_point); end + + # sord omit - no YARD type given for "time", using untyped + # sord omit - no YARD return type given, using untyped + # + # _@see_ `Faraday.timeout=` + sig { params(time: T.untyped).returns(T.untyped) } + def timeout=(time); end + + # sord omit - no YARD return type given, using untyped + # + # _@see_ `Faraday.timeout` + sig { returns(T.untyped) } + def timeout; end + + # sord omit - no YARD type given for "time", using untyped + # sord omit - no YARD return type given, using untyped + # + # _@see_ `Faraday.open_timeout=` + sig { params(time: T.untyped).returns(T.untyped) } + def open_timeout=(time); end + + # sord omit - no YARD return type given, using untyped + # + # _@see_ `Faraday.open_timeout` + sig { returns(T.untyped) } + def open_timeout; end + + # sord omit - no YARD type given for :client, using untyped + # Returns the value of attribute client. + sig { returns(T.untyped) } + attr_reader :client + end + + # Responsible to formatting output of Client#shorten_link + class LinkRenderer + # sord warn - Faraday::Connection wasn't able to be resolved to a constant in this project + # sord warn - "String or Hash" does not appear to be a type + # _@param_ `response` — http reponse + # + # _@return_ — Hash + # + # ```ruby + # { + # :link => short link result + # :preview_link => preview of short link result + # :warning => warning message by Firebase if present + # } + # ``` + sig { params(response: Faraday::Connection).returns(T::Hash[Symbol, SORD_ERROR_StringorHash]) } + def render(response); end + + # sord omit - no YARD type given for "response", using untyped + # sord omit - no YARD return type given, using untyped + sig { params(response: T.untyped).returns(T.untyped) } + def render_success(response); end + + # sord omit - no YARD type given for "response", using untyped + # sord omit - no YARD return type given, using untyped + sig { params(response: T.untyped).returns(T.untyped) } + def raise_error(response); end + + # sord omit - no YARD return type given, using untyped + sig { returns(T.untyped) } + def raise_limit_has_reached; end + end +end diff --git a/sorbet/rbi/gems/appraisal.rbi b/sorbet/rbi/gems/appraisal.rbi new file mode 100644 index 0000000..1331d5e --- /dev/null +++ b/sorbet/rbi/gems/appraisal.rbi @@ -0,0 +1,154 @@ +# 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/appraisal/all/appraisal.rbi +# +# appraisal-2.4.1 + +module Appraisal +end +module Appraisal::Utils + def self.bundler_version; end + def self.format_arguments(arguments); end + def self.format_hash_value(key, value); end + def self.format_string(object, enclosing_object = nil); end + def self.join_parts(parts); end + def self.prefix_path(path); end + def self.support_parallel_installation?; end +end +class Appraisal::Dependency + def for_dup; end + def formatted_output(output_requirements); end + def gem_name; end + def initialize(name, requirements); end + def name; end + def no_requirements?; end + def path_prefixed_requirements; end + def requirements; end + def requirements=(arg0); end + def to_s; end +end +class Appraisal::DependencyList + def add(name, requirements); end + def for_dup; end + def initialize; end + def remove(name); end + def to_s; end +end +class Appraisal::BundlerDSL + def dependencies; end + def dependencies_entry; end + def dependencies_entry_for_dup; end + def for_dup; end + def gem(name, *requirements); end + def gemspec(options = nil); end + def gemspec_entry; end + def gemspec_entry_for_dup; end + def git(source, options = nil, &block); end + def git_source(source, &block); end + def git_sources=(arg0); end + def gits_entry; end + def gits_entry_for_dup; end + def group(*names, &block); end + def groups_entry; end + def groups_entry_for_dup; end + def indent(string); end + def initialize; end + def path(source, options = nil, &block); end + def paths_entry; end + def paths_entry_for_dup; end + def platform(*names, &block); end + def platforms(*names, &block); end + def platforms_entry; end + def platforms_entry_for_dup; end + def remove_gem(name); end + def ruby(ruby_version); end + def ruby_version_entry; end + def ruby_version_entry_for_dup; end + def run(&block); end + def source(source, &block); end + def source_blocks_entry; end + def source_blocks_entry_for_dup; end + def source_entry; end + def source_entry_for_dup; end + def substitute_git_source(requirements); end + def to_s; end +end +class Appraisal::Gemfile < Appraisal::BundlerDSL + def dup; end + def load(path); end + def run(definitions); end +end +class Appraisal::Command + def announce; end + def command; end + def command_as_string; end + def command_starting_with_bundle(original_command); end + def command_starts_with_bundle?(original_command); end + def ensure_bundler_is_available; end + def env; end + def gemfile; end + def initialize(command, options = nil); end + def original_env; end + def restore_env; end + def run; end + def unset_bundler_env_vars; end + def with_clean_env; end +end +class Appraisal::Appraisal + def bundle_options(options); end + def check_command; end + def clean_name; end + def gem(*args); end + def gemfile; end + def gemfile_name; end + def gemfile_path; end + def gemfile_root; end + def gemspec(options = nil); end + def git(*args, &block); end + def git_source(*args, &block); end + def group(*args, &block); end + def initialize(name, source_gemfile); end + def install(options = nil); end + def install_command(options = nil); end + def lockfile_path; end + def name; end + def path(*args, &block); end + def platforms(*args, &block); end + def project_root; end + def relative_gemfile_path; end + def relativize; end + def remove_gem(*args); end + def ruby(*args); end + def source(*args, &block); end + def update(gems = nil); end + def update_command(gems); end + def write_gemfile; end +end +class Appraisal::AppraisalsNotFound < StandardError + def message; end +end +class Appraisal::AppraisalFile + def appraisals; end + def appraise(name, &block); end + def each(&block); end + def gemfile; end + def initialize; end + def path; end + def run(definitions); end + def self.each(&block); end +end +class Appraisal::Task < Rake::TaskLib + def initialize; end +end +class Appraisal::Gemspec + def exported_options; end + def for_dup; end + def initialize(options = nil); end + def options; end + def to_s; end +end diff --git a/sorbet/rbi/gems/ast.rbi b/sorbet/rbi/gems/ast.rbi new file mode 100644 index 0000000..2b18c4a --- /dev/null +++ b/sorbet/rbi/gems/ast.rbi @@ -0,0 +1,49 @@ +# 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/bootsnap.rbi b/sorbet/rbi/gems/bootsnap.rbi new file mode 100644 index 0000000..c8a3b53 --- /dev/null +++ b/sorbet/rbi/gems/bootsnap.rbi @@ -0,0 +1,230 @@ +# 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/bootsnap/all/bootsnap.rbi +# +# bootsnap-1.9.4 + +module Bootsnap + def bundler?; end + def instrumentation_enabled=(arg0); end + def self._instrument(event, path); end + def self.absolute_path?(path); end + def self.default_setup; end + def self.instrumentation=(callback); end + def self.instrumentation_enabled=(arg0); end + def self.iseq_cache_supported?; end + def self.log!; end + def self.logger; end + def self.logger=(logger); end + def self.setup(cache_dir:, development_mode: nil, load_path_cache: nil, autoload_paths_cache: nil, disable_trace: nil, compile_cache_iseq: nil, compile_cache_yaml: nil, compile_cache_json: nil); end + extend Bootsnap +end +module Bootsnap::ExplicitRequire + def self.from_archdir(feature); end + def self.from_rubylibdir(feature); end + def self.from_self(feature); end + def self.with_gems(*gems); end +end +module Bootsnap::LoadPathCache + def self.load_path_cache; end + def self.loaded_features_index; end + def self.realpath_cache; end + def self.setup(cache_path:, development_mode:); end + def self.supported?; end +end +module Bootsnap::LoadPathCache::PathScanner + def self.call(path); end + def self.os_path(path); end + def self.walk(absolute_dir_path, relative_dir_path, &block); end +end +class Bootsnap::LoadPathCache::Path + def entries_and_dirs(store); end + def expanded_path; end + def initialize(path); end + def latest_mtime(path, dirs); end + def non_directory?; end + def path; end + def relative?; end + def scan!; end + def stability; end + def stable?; end + def volatile?; end +end +class Bootsnap::LoadPathCache::Cache + def dir_changed?; end + def expand_path(feature); end + def find(feature, try_extensions: nil); end + def initialize(store, path_obj, development_mode: nil); end + def load_dir(dir); end + def maybe_append_extension(f); end + def now; end + def push_paths(sender, *paths); end + def push_paths_locked(*paths); end + def reinitialize(path_obj = nil); end + def search_index(f, try_extensions: nil); end + def stale?; end + def try_ext(f); end + def try_index(f); end + def unshift_paths(sender, *paths); end + def unshift_paths_locked(*paths); end +end +class Bootsnap::LoadPathCache::Store + def commit_transaction; end + def default_data; end + def dump_data; end + def fetch(key); end + def get(key); end + def initialize(store_path); end + def load_data; end + def set(key, value); end + def transaction; end +end +class Bootsnap::LoadPathCache::Store::NestedTransactionError < StandardError +end +class Bootsnap::LoadPathCache::Store::SetOutsideTransactionNotAllowed < StandardError +end +module Bootsnap::LoadPathCache::ChangeObserver + def self.register(observer, arr); end +end +module Bootsnap::LoadPathCache::ChangeObserver::ArrayMixin + def <<(entry); end + def []=(*args, &block); end + def append(*entries); end + def clear(*args, &block); end + def collect!(*args, &block); end + def compact!(*args, &block); end + def concat(entries); end + def delete(*args, &block); end + def delete_at(*args, &block); end + def delete_if(*args, &block); end + def fill(*args, &block); end + def flatten!(*args, &block); end + def insert(*args, &block); end + def keep_if(*args, &block); end + def map!(*args, &block); end + def pop(*args, &block); end + def prepend(*entries); end + def push(*entries); end + def reject!(*args, &block); end + def replace(*args, &block); end + def reverse!(*args, &block); end + def rotate!(*args, &block); end + def select!(*args, &block); end + def shift(*args, &block); end + def shuffle!(*args, &block); end + def slice!(*args, &block); end + def sort!(*args, &block); end + def sort_by!(*args, &block); end + def uniq!(*args); end + def unshift(*entries); end +end +class Bootsnap::LoadPathCache::LoadedFeaturesIndex + def extension_elidable?(f); end + def initialize; end + def key?(feature); end + def purge(feature); end + def purge_multi(features); end + def register(short, long = nil); end + def strip_extension_if_elidable(f); end +end +class Bootsnap::LoadPathCache::RealpathCache + def call(*key); end + def find_file(name); end + def initialize; end + def realpath(caller_location, path); end +end +class Bootsnap::LoadPathCache::ReturnFalse < StandardError +end +class Bootsnap::LoadPathCache::FallbackScan < StandardError +end +module Bootsnap::CompileCache + def self.permission_error(path); end + def self.setup(cache_dir:, iseq:, yaml:, json:); end + def self.supported?; end +end +class Bootsnap::CompileCache::Error < StandardError +end +class Bootsnap::CompileCache::PermissionError < Bootsnap::CompileCache::Error +end +class Bootsnap::InvalidConfiguration < StandardError +end +module Bootsnap::LoadPathCache::CoreExt + def self.make_load_error(path); end +end +module Kernel + def load_without_bootsnap(*arg0); end + def require_relative_without_bootsnap(arg0); end + def require_with_bootsnap_lfi(path, resolved = nil); end + def require_without_bootsnap(arg0); end + def self.require_with_bootsnap_lfi(path, resolved = nil); end +end +class Module + def autoload_without_bootsnap(arg0, arg1); end +end +module Bootsnap::CompileCache::Native + def compile_option_crc32=(arg0); end + def coverage_running?; end + def fetch(arg0, arg1, arg2, arg3); end + def precompile(arg0, arg1, arg2); end + def self.compile_option_crc32=(arg0); end + def self.coverage_running?; end + def self.fetch(arg0, arg1, arg2, arg3); end + def self.precompile(arg0, arg1, arg2); end +end +module Bootsnap::CompileCache::ISeq + def self.cache_dir; end + def self.cache_dir=(arg0); end + def self.compile_option_updated; end + def self.fetch(path, cache_dir: nil); end + def self.input_to_output(_data, _kwargs); end + def self.input_to_storage(_, path); end + def self.install!(cache_dir); end + def self.precompile(path, cache_dir: nil); end + def self.storage_to_output(binary, _args); end +end +module Bootsnap::CompileCache::ISeq::InstructionSequenceMixin + def compile_option=(hash); end + def load_iseq(path); end +end +module Bootsnap::CompileCache::YAML + def self.cache_dir; end + def self.cache_dir=(arg0); end + def self.init!; end + def self.input_to_output(data, kwargs); end + def self.input_to_storage(contents, _); end + def self.install!(cache_dir); end + def self.msgpack_factory; end + def self.msgpack_factory=(arg0); end + def self.precompile(path, cache_dir: nil); end + def self.storage_to_output(data, kwargs); end + def self.strict_load(payload, *args); end + def self.strict_visitor; end + def self.supported_options; end + def self.supported_options=(arg0); end +end +module Bootsnap::CompileCache::YAML::Patch + def load_file(path, *args); end + def unsafe_load_file(path, *args); end +end +module Bootsnap::CompileCache::JSON + def self.cache_dir; end + def self.cache_dir=(arg0); end + def self.init!; end + def self.input_to_output(data, kwargs); end + def self.input_to_storage(payload, _); end + def self.install!(cache_dir); end + def self.msgpack_factory; end + def self.msgpack_factory=(arg0); end + def self.precompile(path, cache_dir: nil); end + def self.storage_to_output(data, kwargs); end + def self.supported_options; end + def self.supported_options=(arg0); end +end +module Bootsnap::CompileCache::JSON::Patch + def load_file(path, *args); end +end diff --git a/sorbet/rbi/gems/bundler-audit.rbi b/sorbet/rbi/gems/bundler-audit.rbi new file mode 100644 index 0000000..6167c15 --- /dev/null +++ b/sorbet/rbi/gems/bundler-audit.rbi @@ -0,0 +1,85 @@ +# 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/case_transform2.rbi b/sorbet/rbi/gems/case_transform2.rbi new file mode 100644 index 0000000..e2dc520 --- /dev/null +++ b/sorbet/rbi/gems/case_transform2.rbi @@ -0,0 +1,33 @@ +# 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/case_transform2/all/case_transform2.rbi +# +# case_transform2-1.1.1 + +module CaseTransform2 + def self.camel(value); end + def self.camel_cache; end + def self.camel_lower(value); end + def self.camel_lower_cache; end + def self.dash(value); end + def self.dash_cache; end + def self.hash_ext; end + def self.string_ext; end + def self.unaltered(value); end + def self.underscore(value); end + def self.underscore_cache; end +end +class CaseTransform2::HashExt + def _deep_transform_keys_in_object!(object, &block); end + def deep_transform_keys!(object, &block); end +end +class CaseTransform2::StringExt + def camelize(string, first_letter = nil); end + def dasherize(string); end + def underscore(string); end +end diff --git a/sorbet/rbi/gems/coderay.rbi b/sorbet/rbi/gems/coderay.rbi new file mode 100644 index 0000000..68e3e0d --- /dev/null +++ b/sorbet/rbi/gems/coderay.rbi @@ -0,0 +1,285 @@ +# 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/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::FileType + def self.[](filename, read_shebang = nil); end + def self.fetch(filename, default = nil, read_shebang = nil); end + def self.type_from_shebang(filename); end +end +class CodeRay::FileType::UnknownFileType < Exception +end +class CodeRay::Tokens < Array + def begin_group(kind); end + def begin_line(kind); end + def count; end + def encode(encoder, options = nil); end + def end_group(kind); end + def end_line(kind); end + def method_missing(meth, options = nil); end + def scanner; end + def scanner=(arg0); end + def split_into_parts(*sizes); end + def text_token(*arg0); end + def to_s; end + def tokens(*arg0); end +end +class CodeRay::TokensProxy + def block; end + def block=(arg0); end + def each(*args, &blk); end + def encode(encoder, options = nil); end + def initialize(input, lang, options = nil, block = nil); end + def input; end + def input=(arg0); end + def lang; end + def lang=(arg0); end + def method_missing(method, *args, &blk); end + def options; end + def options=(arg0); end + def scanner; end + def tokens; 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::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 +module CodeRay::Scanners + extend CodeRay::PluginHost +end +class CodeRay::Scanners::Scanner < StringScanner + def binary_string; end + def column(pos = nil); end + def each(&block); end + def file_extension; end + def initialize(code = nil, options = nil); end + def lang; end + def line(pos = nil); end + def raise_inspect(message, tokens, state = nil, ambit = nil, backtrace = nil); end + def raise_inspect_arguments(message, tokens, state, ambit); end + def reset; end + def reset_instance; end + def scan_rest; end + def scan_tokens(tokens, options); end + def scanner_state_info(state); end + def self.encode_with_encoding(code, target_encoding); end + def self.encoding(name = nil); end + def self.file_extension(extension = nil); end + def self.guess_encoding(s); end + def self.lang; end + def self.normalize(code); end + def self.to_unix(code); end + def set_string_from_source(source); end + def set_tokens_from_options(options); end + def setup; end + def state; end + def state=(arg0); end + def string=(code); end + def tokenize(source = nil, options = nil); end + def tokens; end + def tokens_last(tokens, n); end + def tokens_size(tokens); end + extend CodeRay::Plugin + include Enumerable +end +class CodeRay::Scanners::Scanner::ScanError < StandardError +end +class CodeRay::WordList < Hash + def add(words, value = nil); end + def initialize(default = nil); end +end +class CodeRay::WordList::CaseIgnoring < CodeRay::WordList + def [](key); end + def []=(key, value); end +end +module CodeRay::Scanners::Java::BuiltinTypes +end +class CodeRay::Scanners::Java < CodeRay::Scanners::Scanner + def scan_tokens(encoder, options); end +end +class CodeRay::Scanners::Ruby < CodeRay::Scanners::Scanner + def interpreted_string_state; end + def scan_tokens(encoder, options); end + def setup; end +end +module CodeRay::Scanners::Ruby::Patterns +end +class Anonymous_Struct_2 < Struct + def delim; end + def delim=(_); end + def heredoc; end + def heredoc=(_); end + def interpreted; end + def interpreted=(_); end + def next_state; end + def next_state=(_); end + def opening_paren; end + def opening_paren=(_); end + def paren_depth; end + def paren_depth=(_); end + def pattern; end + def pattern=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def type; end + def type=(_); end +end +class CodeRay::Scanners::Ruby::StringState < Anonymous_Struct_2 + def heredoc_pattern(delim, interpreted, indented); end + def initialize(kind, interpreted, delim, heredoc = nil); end + def self.simple_key_pattern(delim); end +end +module CodeRay::Encoders + extend CodeRay::PluginHost +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::HTML < CodeRay::Encoders::Encoder + def begin_group(kind); end + def begin_line(kind); end + def break_lines(text, style); end + def check_group_nesting(name, kind); end + def check_options!(options); end + def close_span; end + def css; end + def css_class_for_kinds(kinds); end + def end_group(kind); end + def end_line(kind); end + def finish(options); end + def make_span_for_kinds(method, hint); end + def self.make_html_escape_hash; end + def self.token_path_to_hint(hint, kinds); end + def setup(options); end + def style_for_kinds(kinds); end + def text_token(text, kind); end +end +module CodeRay::Encoders::HTML::Output + def apply_title!(title); end + def css; end + def css=(arg0); end + def self.extended(o); end + def self.make_stylesheet(css, in_tag = nil); end + def self.page_template_for_css(css); end + def stylesheet(in_tag = nil); end + def wrap!(element, *args); end + def wrap_in!(template); end + def wrapped_in; end + def wrapped_in=(arg0); end + def wrapped_in?(element); end +end +class CodeRay::Encoders::HTML::Output::Template < String + def apply(target, replacement); end + def self.wrap!(str, template, target); end +end +class CodeRay::Encoders::HTML::CSS + def get_style_for_css_classes(css_classes); end + def initialize(style = nil); end + def parse(stylesheet); end + def self.load_stylesheet(style = nil); end + def stylesheet; end +end +module CodeRay::Encoders::HTML::Numbering + def self.number!(output, mode = nil, options = nil); end +end +module CodeRay::Styles + extend CodeRay::PluginHost +end +class CodeRay::Styles::Style + extend CodeRay::Plugin +end +class CodeRay::Duo + def call(code, options = nil); end + def encode(code, options = nil); end + def encoder; end + def format; end + def format=(arg0); end + def highlight(code, options = nil); end + def initialize(lang = nil, format = nil, options = nil); end + def lang; end + def lang=(arg0); end + def options; end + def options=(arg0); end + def scanner; end + def self.[](*arg0); end +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/commander.rbi b/sorbet/rbi/gems/commander.rbi new file mode 100644 index 0000000..d357100 --- /dev/null +++ b/sorbet/rbi/gems/commander.rbi @@ -0,0 +1,197 @@ +# 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/commander/all/commander.rbi +# +# commander-4.6.0 + +module Commander + def configure(*configuration_opts, &configuration_block); end + def self.configure(*configuration_opts, &configuration_block); end +end +module Blank + def self.included(base); end +end +module Commander::UI + def applescript(script); end + def ask_editor(input = nil, preferred_editor = nil); end + def available_editor(preferred = nil); end + def choose(message = nil, *choices, &block); end + def color(*args); end + def converse(prompt, responses = nil); end + def enable_paging; end + def io(input = nil, output = nil, &block); end + def log(action, *args); end + def password(message = nil, mask = nil); end + def progress(arr, options = nil); end + def replace_tokens(str, hash); end + def say_error(*args); end + def say_ok(*args); end + def say_warning(*args); end + def self.applescript(script); end + def self.ask_editor(input = nil, preferred_editor = nil); end + def self.available_editor(preferred = nil); end + def self.choose(message = nil, *choices, &block); end + def self.color(*args); end + def self.converse(prompt, responses = nil); end + def self.enable_paging; end + def self.io(input = nil, output = nil, &block); end + def self.log(action, *args); end + def self.password(message = nil, mask = nil); end + def self.progress(arr, options = nil); end + def self.replace_tokens(str, hash); end + def self.say_error(*args); end + def self.say_ok(*args); end + def self.say_warning(*args); end + def self.speak(message, voice = nil, rate = nil); end + def speak(message, voice = nil, rate = nil); end +end +module Commander::UI::AskForClass + def ask_for_array(prompt); end + def ask_for_file(prompt); end + def ask_for_float(prompt); end + def ask_for_integer(prompt); end + def ask_for_pathname(prompt); end + def ask_for_regexp(prompt); end + def ask_for_string(prompt); end + def ask_for_symbol(prompt); end + def method_missing(method_name, *arguments, &block); end + def respond_to_missing?(method_name, include_private = nil); end +end +class Commander::UI::ProgressBar + def completed?; end + def erase_line; end + def finished?; end + def generate_tokens; end + def increment(tokens = nil); end + def initialize(total, options = nil); end + def percent_complete; end + def progress_bar; end + def show; end + def steps_remaining; end + def time_elapsed; end + def time_remaining; end +end +class Array + def self.parse(string); end +end +class Object < BasicObject + def get_binding; end +end +class Commander::Runner + def active_command; end + def add_command(command); end + def alias?(name); end + def alias_command(alias_name, name, *args); end + def always_trace!; end + def args_without_command_name; end + def command(name, &block); end + def command_exists?(name); end + def command_name_from_args; end + def commands; end + def create_default_commands; end + def default_command(name); end + def expand_optionally_negative_switches(switches); end + def global_option(*args, &block); end + def global_option_proc(switches, &block); end + def help_formatter; end + def help_formatter_alias_defaults; end + def help_formatter_aliases; end + def initialize(args = nil); end + def longest_valid_command_name_from(args); end + def never_trace!; end + def options; end + def parse_global_options; end + def program(key, *args, &block); end + def program_defaults; end + def remove_global_options(options, args); end + def require_program(*keys); end + def require_valid_command(command = nil); end + def run!; end + def run_active_command; end + def say(*args); end + def self.instance; end + def self.separate_switches_from_description(*args); end + def self.switch_to_sym(switch); end + def valid_command_names_from(*args); end + def version; end +end +class Commander::Runner::CommandError < StandardError +end +class Commander::Runner::InvalidCommandError < Commander::Runner::CommandError +end +class Commander::Command + def action(*args, &block); end + def call(args = nil); end + def description; end + def description=(arg0); end + def example(description, command); end + def examples; end + def examples=(arg0); end + def global_options; end + def initialize(name); end + def inspect; end + def name; end + def name=(arg0); end + def option(*args, &block); end + def option_proc(switches); end + def options; end + def options=(arg0); end + def parse_options_and_call_procs(*args); end + def proxy_option_struct; end + def proxy_options; end + def proxy_options=(arg0); end + def run(*args); end + def summary; end + def summary=(arg0); end + def syntax; end + def syntax=(arg0); end + def when_called(*args, &block); end +end +class Commander::Command::Options + def __hash__; end + def default(defaults = nil); end + def initialize; end + def inspect; end + def method_missing(meth, *args); end + include Blank +end +module Commander::HelpFormatter + def indent(amount, text); end + def self.indent(amount, text); end +end +class Commander::HelpFormatter::Context + def decorate_binding(_bind); end + def get_binding; end + def initialize(target); end +end +class Commander::HelpFormatter::ProgramContext < Commander::HelpFormatter::Context + def decorate_binding(bind); end + def max_aliases_length(bind); end + def max_command_length(bind); end + def max_key_length(hash, default = nil); end +end +module Commander::Platform + def self.jruby?; end +end +module Commander::Delegates + def add_command(*args, &block); end + def alias_command(*args, &block); end + def always_trace!(*args, &block); end + def command(*args, &block); end + def default_command(*args, &block); end + def defined_commands(*args, &block); end + def global_option(*args, &block); end + def never_trace!(*args, &block); end + def program(*args, &block); end + def run!(*args, &block); end +end +module Commander::Methods + include Commander::Delegates + include Commander::UI + include Commander::UI::AskForClass +end diff --git a/sorbet/rbi/gems/concurrent-ruby.rbi b/sorbet/rbi/gems/concurrent-ruby.rbi new file mode 100644 index 0000000..2354553 --- /dev/null +++ b/sorbet/rbi/gems/concurrent-ruby.rbi @@ -0,0 +1,229 @@ +# 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/concurrent-ruby/all/concurrent-ruby.rbi +# +# concurrent-ruby-1.1.10 + +module Concurrent + extend Concurrent::Utility::EngineDetector + extend Concurrent::Utility::NativeExtensionLoader +end +module Concurrent::Utility +end +module Concurrent::Utility::EngineDetector + def on_cruby?; end + def on_jruby?; end + def on_jruby_9000?; end + def on_linux?; end + def on_osx?; end + def on_rbx?; end + def on_truffleruby?; end + def on_windows?; end + def ruby_engine; end + def ruby_version(version = nil, comparison, major, minor, patch); end +end +module Concurrent::ThreadSafe +end +module Concurrent::ThreadSafe::Util +end +class Concurrent::Array < Array +end +module Concurrent::Synchronization +end +class Concurrent::Synchronization::AbstractObject + def full_memory_barrier; end + def initialize; end + def self.attr_volatile(*names); end +end +module Concurrent::Utility::NativeExtensionLoader + def allow_c_extensions?; end + def c_extensions_loaded?; end + def java_extensions_loaded?; end + def load_error_path(error); end + def load_native_extensions; end + def set_c_extensions_loaded; end + def set_java_extensions_loaded; end + def try_load_c_extension(path); end +end +module Concurrent::Synchronization::MriAttrVolatile + def full_memory_barrier; end + def self.included(base); end +end +module Concurrent::Synchronization::MriAttrVolatile::ClassMethods + def attr_volatile(*names); end +end +class Concurrent::Synchronization::MriObject < Concurrent::Synchronization::AbstractObject + def initialize; end + extend Concurrent::Synchronization::MriAttrVolatile::ClassMethods + include Concurrent::Synchronization::MriAttrVolatile +end +module Concurrent::Synchronization::RbxAttrVolatile + def full_memory_barrier; end + def self.included(base); end +end +module Concurrent::Synchronization::RbxAttrVolatile::ClassMethods + def attr_volatile(*names); end +end +class Concurrent::Synchronization::RbxObject < Concurrent::Synchronization::AbstractObject + def initialize; end + extend Concurrent::Synchronization::RbxAttrVolatile::ClassMethods + include Concurrent::Synchronization::RbxAttrVolatile +end +module Concurrent::Synchronization::TruffleRubyAttrVolatile + def full_memory_barrier; end + def self.included(base); end +end +module Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods + def attr_volatile(*names); end +end +class Concurrent::Synchronization::TruffleRubyObject < Concurrent::Synchronization::AbstractObject + def initialize; end + extend Concurrent::Synchronization::TruffleRubyAttrVolatile::ClassMethods + include Concurrent::Synchronization::TruffleRubyAttrVolatile +end +class Concurrent::Synchronization::Object < Concurrent::Synchronization::MriObject + def __initialize_atomic_fields__; end + def initialize; end + def self.atomic_attribute?(name); end + def self.atomic_attributes(inherited = nil); end + def self.attr_atomic(*names); end + def self.define_initialize_atomic_fields; end + def self.ensure_safe_initialization_when_final_fields_are_present; end + def self.safe_initialization!; end + def self.safe_initialization?; end +end +class Concurrent::Synchronization::AbstractLockableObject < Concurrent::Synchronization::Object + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = nil); end + def ns_wait_until(timeout = nil, &condition); end + def synchronize; end +end +module Concurrent::Synchronization::ConditionSignalling + def ns_broadcast; end + def ns_signal; end +end +class Concurrent::Synchronization::MutexLockableObject < Concurrent::Synchronization::AbstractLockableObject + def initialize(*defaults); end + def initialize_copy(other); end + def ns_wait(timeout = nil); end + def self.new(*args, &block); end + def synchronize; end + include Concurrent::Synchronization::ConditionSignalling +end +class Concurrent::Synchronization::MonitorLockableObject < Concurrent::Synchronization::AbstractLockableObject + def initialize(*defaults); end + def initialize_copy(other); end + def ns_wait(timeout = nil); end + def self.new(*args, &block); end + def synchronize; end + include Concurrent::Synchronization::ConditionSignalling +end +class Concurrent::Synchronization::RbxLockableObject < Concurrent::Synchronization::AbstractLockableObject + def initialize(*defaults); end + def initialize_copy(other); end + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = nil); end + def self.new(*args, &block); end + def synchronize(&block); end +end +class Concurrent::Synchronization::LockableObject < Concurrent::Synchronization::MutexLockableObject + def new_condition; end +end +class Concurrent::Synchronization::Condition < Concurrent::Synchronization::LockableObject + def broadcast; end + def initialize(lock); end + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = nil); end + def ns_wait_until(timeout = nil, &condition); end + def self.new(*args, &block); end + def self.private_new(*args, &block); end + def signal; end + def wait(timeout = nil); end + def wait_until(timeout = nil, &condition); end +end +class Concurrent::Synchronization::Lock < Concurrent::Synchronization::LockableObject + def broadcast; end + def ns_broadcast; end + def ns_signal; end + def ns_wait(timeout = nil); end + def ns_wait_until(timeout = nil, &condition); end + def signal; end + def synchronize; end + def wait(timeout = nil); end + def wait_until(timeout = nil, &condition); end +end +module Concurrent::Collection +end +class Concurrent::Collection::NonConcurrentMapBackend + def [](key); end + def []=(key, value); end + def _get(key); end + def _set(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def dupped_backend; end + def each_pair; end + def get_and_set(key, value); end + def get_or_default(key, default_value); end + def initialize(options = nil); end + def initialize_copy(other); end + def key?(key); end + def merge_pair(key, value); end + def pair?(key, expected_value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end + def size; end + def store_computed_value(key, new_value); end +end +class Concurrent::Collection::MriMapBackend < Concurrent::Collection::NonConcurrentMapBackend + def []=(key, value); end + def clear; end + def compute(key); end + def compute_if_absent(key); end + def compute_if_present(key); end + def delete(key); end + def delete_pair(key, value); end + def get_and_set(key, value); end + def initialize(options = nil); end + def merge_pair(key, value); end + def replace_if_exists(key, new_value); end + def replace_pair(key, old_value, new_value); end +end +class Concurrent::Map < Concurrent::Collection::MriMapBackend + def [](key); end + def []=(key, value); end + def each; end + def each_key; end + def each_pair; end + def each_value; end + def empty?; end + def fetch(key, default_value = nil); end + def fetch_or_store(key, default_value = nil); end + def get(key); end + def initialize(options = nil, &block); end + def initialize_copy(other); end + def inspect; end + def key(value); end + def keys; end + def marshal_dump; end + def marshal_load(hash); end + def populate_from(hash); end + def put(key, value); end + def put_if_absent(key, value); end + def raise_fetch_no_key; end + def validate_options_hash!(options); end + def value?(value); end + def values; end +end diff --git a/sorbet/rbi/gems/docile.rbi b/sorbet/rbi/gems/docile.rbi new file mode 100644 index 0000000..6314c6c --- /dev/null +++ b/sorbet/rbi/gems/docile.rbi @@ -0,0 +1,36 @@ +# 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/dotenv.rbi b/sorbet/rbi/gems/dotenv.rbi new file mode 100644 index 0000000..0e2a9f5 --- /dev/null +++ b/sorbet/rbi/gems/dotenv.rbi @@ -0,0 +1,68 @@ +# 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/dotenv/all/dotenv.rbi +# +# dotenv-2.7.6 + +module Dotenv + def ignoring_nonexistent_files; end + def instrument(name, payload = nil, &block); end + def load!(*filenames); end + def load(*filenames); end + def overload!(*filenames); end + def overload(*filenames); end + def parse(*filenames); end + def require_keys(*keys); end + def self.ignoring_nonexistent_files; end + def self.instrument(name, payload = nil, &block); end + def self.instrumenter; end + def self.instrumenter=(arg0); end + def self.load!(*filenames); end + def self.load(*filenames); end + def self.overload!(*filenames); end + def self.overload(*filenames); end + def self.parse(*filenames); end + def self.require_keys(*keys); end + def self.with(*filenames); end + def with(*filenames); end +end +module Dotenv::Substitutions +end +module Dotenv::Substitutions::Variable + def self.call(value, env, is_load); end + def self.substitute(match, variable, env); end +end +module Dotenv::Substitutions::Command + def self.call(value, _env, _is_load); end +end +class Dotenv::FormatError < SyntaxError +end +class Dotenv::Parser + def call; end + def expand_newlines(value); end + def initialize(string, is_load = nil); end + def parse_line(line); end + def parse_value(value); end + def self.call(string, is_load = nil); end + def self.substitutions; end + def unescape_characters(value); end + def variable_not_set?(line); end +end +class Dotenv::Environment < Hash + def apply!; end + def apply; end + def filename; end + def initialize(filename, is_load = nil); end + def load(is_load = nil); end + def read; end +end +class Dotenv::Error < StandardError +end +class Dotenv::MissingKeys < Dotenv::Error + def initialize(keys); end +end diff --git a/sorbet/rbi/gems/dry-configurable.rbi b/sorbet/rbi/gems/dry-configurable.rbi new file mode 100644 index 0000000..b1a6adb --- /dev/null +++ b/sorbet/rbi/gems/dry-configurable.rbi @@ -0,0 +1,152 @@ +# 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/dry-configurable/all/dry-configurable.rbi +# +# dry-configurable-0.15.0 + +module Dry +end +module Dry::Configurable + def enable_test_interface; end + def self.extended(klass); end + def self.included(klass); end + extend Anonymous_Module_3 + extend Anonymous_Module_4 + extend Dry::Core::ClassAttributes + include Dry::Core::Constants +end +module Anonymous_Module_3 + def inherited(klass); end + def warn_on_setting_positional_default(value = nil); end +end +module Anonymous_Module_4 + def inherited(klass); end + def warn_on_setting_constructor_block(value = nil); end +end +class Dry::Configurable::Error < StandardError +end +class Dry::Configurable::AlreadyIncluded < Dry::Configurable::Error +end +class Dry::Configurable::FrozenConfig < Dry::Configurable::Error +end +class Dry::Configurable::Config + def [](name); end + def []=(name, value); end + def _resolved; end + def _settings; end + def finalize!(freeze_values: nil); end + def initialize(settings); end + def initialize_copy(source); end + def method_missing(meth, *args); end + def pristine; end + def resolve(meth); end + def respond_to_missing?(meth, include_private = nil); end + def to_h; end + def update(values); end + def values; end + include Anonymous_Dry_Core_Equalizer_5 + include Dry::Core::Equalizer::Methods +end +module Anonymous_Dry_Core_Equalizer_5 + def cmp?(comparator, other); end + def hash; end + def inspect; end +end +class Dry::Configurable::Setting + def cloneable?; end + def constructor; end + def default; end + def evaluate; end + def evaluated?; end + def finalize!(freeze_values: nil); end + def initialize(name, input: nil, default: nil, **options); end + def initialize_copy(source); end + def input; end + def input_defined?; end + def name; end + def nested(settings); end + def options; end + def pristine; end + def reader?; end + def self.cloneable_value?(value); end + def value; end + def with(new_opts); end + def writer?(meth); end + def writer_name; end + include Anonymous_Dry_Core_Equalizer_6 + include Dry::Core::Equalizer::Methods +end +module Anonymous_Dry_Core_Equalizer_6 + def cmp?(comparator, other); end + def hash; end +end +class Dry::Configurable::Setting::Nested < Dry::Configurable::Setting + def constructor; end + def pristine; end +end +class Dry::Configurable::Settings + def <<(setting); end + def [](name); end + def each(&block); end + def elements; end + def finalize!(freeze_values: nil); end + def initialize(elements = nil); end + def initialize_copy(source); end + def initialize_elements(elements); end + def key?(name); end + def keys; end + def pristine; end + include Anonymous_Dry_Core_Equalizer_7 + include Dry::Core::Equalizer::Methods + include Enumerable +end +module Anonymous_Dry_Core_Equalizer_7 + def cmp?(comparator, other); end + def hash; end + def inspect; end +end +class Dry::Configurable::Compiler + def call(ast); end + def visit(node); end + def visit_nested(node); end + def visit_setting(node); end +end +class Dry::Configurable::DSL + def ast; end + def compiler; end + def ensure_valid_options(options); end + def initialize(&block); end + def setting(name, default = nil, **options, &block); end + def valid_and_invalid_options(options); end +end +module Dry::Configurable::Methods + def configure(&block); end + def finalize!(freeze_values: nil); end +end +module Dry::Configurable::ClassMethods + def __config_dsl__; end + def __config_reader__; end + def _settings; end + def config; end + def inherited(subclass); end + def setting(*args, **options, &block); end + def settings; end + include Dry::Configurable::Methods +end +module Dry::Configurable::Initializer + def initialize(*arg0); end +end +module Dry::Configurable::InstanceMethods + def config; end + def finalize!(freeze_values: nil); end + def initialize_copy(source); end + include Dry::Configurable::Methods +end +module Dry::Configurable::TestInterface + def reset_config; end +end diff --git a/sorbet/rbi/gems/dry-core.rbi b/sorbet/rbi/gems/dry-core.rbi new file mode 100644 index 0000000..4c09d0e --- /dev/null +++ b/sorbet/rbi/gems/dry-core.rbi @@ -0,0 +1,58 @@ +# 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/dry-core/all/dry-core.rbi +# +# dry-core-0.7.1 + +module Dry + def self.Equalizer(*keys, **options); end +end +module Dry::Core +end +module Dry::Core::Constants + def self.included(base); end +end +class Dry::Core::InvalidClassAttributeValue < StandardError + def initialize(name, value); end +end +module Dry::Core::ClassAttributes + def defines(*args, type: nil, coerce: nil); end + include Dry::Core::Constants +end +class Dry::Core::Equalizer < Module + def define_cmp_method; end + def define_hash_method(immutable:); end + def define_inspect_method; end + def define_methods(inspect: nil, immutable: nil); end + def included(descendant); end + def initialize(*keys, **options); end +end +module Dry::Core::Equalizer::Methods + def ==(other); end + def eql?(other); end +end +module Dry::Core::Deprecations + def self.[](tag); end + def self.announce(name, msg, tag: nil, uplevel: nil); end + def self.deprecated_name_message(old, new = nil, msg = nil); end + def self.deprecation_message(name, msg); end + def self.logger(output = nil); end + def self.set_logger!(output = nil); end + def self.warn(msg, tag: nil, uplevel: nil); end +end +class Dry::Core::Deprecations::Tagged < Module + def extended(base); end + def initialize(tag); end +end +module Dry::Core::Deprecations::Interface + def deprecate(old_name, new_name = nil, message: nil); end + def deprecate_class_method(old_name, new_name = nil, message: nil); end + def deprecate_constant(constant_name, message: nil); end + def deprecation_tag(tag = nil); end + def warn(msg); end +end diff --git a/sorbet/rbi/gems/faraday-net_http.rbi b/sorbet/rbi/gems/faraday-net_http.rbi new file mode 100644 index 0000000..f07a6fc --- /dev/null +++ b/sorbet/rbi/gems/faraday-net_http.rbi @@ -0,0 +1,33 @@ +# 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/faraday-net_http/all/faraday-net_http.rbi +# +# faraday-net_http-2.0.3 + +module Faraday +end +class Faraday::Adapter +end +class Faraday::Adapter::NetHttp < Faraday::Adapter + def build_connection(env); end + def call(env); end + def configure_request(http, req); end + def configure_ssl(http, ssl); end + def create_request(env); end + def encoded_body(http_response); end + def initialize(app = nil, opts = nil, &block); end + def net_http_connection(env); end + def perform_request(http, env); end + def request_via_get_method(http, env, &block); end + def request_via_request_method(http, env, &block); end + def request_with_wrapped_block(http, env, &block); end + def ssl_cert_store(ssl); end + def ssl_verify_mode(ssl); end +end +module Faraday::NetHttp +end diff --git a/sorbet/rbi/gems/faraday.rbi b/sorbet/rbi/gems/faraday.rbi new file mode 100644 index 0000000..75648a2 --- /dev/null +++ b/sorbet/rbi/gems/faraday.rbi @@ -0,0 +1,698 @@ +# 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/faraday/all/faraday.rbi +# +# faraday-2.3.0 + +module Faraday + def self.default_adapter; end + def self.default_adapter=(adapter); end + def self.default_adapter_options; end + def self.default_adapter_options=(arg0); end + def self.default_connection; end + def self.default_connection=(arg0); end + def self.default_connection_options; end + def self.default_connection_options=(options); end + def self.ignore_env_proxy; end + def self.ignore_env_proxy=(arg0); end + def self.lib_path; end + def self.lib_path=(arg0); end + def self.method_missing(name, *args, &block); end + def self.new(url = nil, options = nil, &block); end + def self.respond_to_missing?(symbol, include_private = nil); end + def self.root_path; end + def self.root_path=(arg0); end +end +class Faraday::Error < StandardError + def backtrace; end + def exc_msg_and_response!(exc, response = nil); end + def exc_msg_and_response(exc, response = nil); end + def initialize(exc = nil, response = nil); end + def inspect; end + def response; end + def response_body; end + def response_headers; end + def response_status; end + def wrapped_exception; end +end +class Faraday::ClientError < Faraday::Error +end +class Faraday::BadRequestError < Faraday::ClientError +end +class Faraday::UnauthorizedError < Faraday::ClientError +end +class Faraday::ForbiddenError < Faraday::ClientError +end +class Faraday::ResourceNotFound < Faraday::ClientError +end +class Faraday::ProxyAuthError < Faraday::ClientError +end +class Faraday::ConflictError < Faraday::ClientError +end +class Faraday::UnprocessableEntityError < Faraday::ClientError +end +class Faraday::ServerError < Faraday::Error +end +class Faraday::TimeoutError < Faraday::ServerError + def initialize(exc = nil, response = nil); end +end +class Faraday::NilStatusError < Faraday::ServerError + def initialize(exc, response = nil); end +end +class Faraday::ConnectionFailed < Faraday::Error +end +class Faraday::SSLError < Faraday::Error +end +class Faraday::ParsingError < Faraday::Error +end +module Faraday::MiddlewareRegistry + def load_middleware(key); end + def lookup_middleware(key); end + def middleware_mutex(&block); end + def register_middleware(**mappings); end + def registered_middleware; end + def unregister_middleware(key); end +end +module Faraday::Utils + def URI(url); end + def basic_header_from(login, pass); end + def build_nested_query(params); end + def build_query(params); end + def deep_merge!(target, hash); end + def deep_merge(source, hash); end + def default_params_encoder; end + def default_space_encoding; end + def default_uri_parser; end + def default_uri_parser=(parser); end + def escape(str); end + def normalize_path(url); end + def parse_nested_query(query); end + def parse_query(query); end + def self.URI(url); end + def self.basic_header_from(login, pass); end + def self.build_nested_query(params); end + def self.build_query(params); end + def self.deep_merge!(target, hash); end + def self.deep_merge(source, hash); end + def self.default_params_encoder; end + def self.default_params_encoder=(arg0); end + def self.default_space_encoding; end + def self.default_space_encoding=(arg0); end + def self.default_uri_parser; end + def self.default_uri_parser=(parser); end + def self.escape(str); end + def self.normalize_path(url); end + def self.parse_nested_query(query); end + def self.parse_query(query); end + def self.sort_query_params(query); end + def self.unescape(str); end + def sort_query_params(query); end + def unescape(str); end +end +class Faraday::Utils::Headers < Hash + def [](key); end + def []=(key, val); end + def add_parsed(key, value); end + def delete(key); end + def fetch(key, *args, &block); end + def has_key?(key); end + def include?(key); end + def initialize(hash = nil); end + def initialize_copy(other); end + def initialize_names; end + def key?(key); end + def member?(key); end + def merge!(other); end + def merge(other); end + def names; end + def parse(header_string); end + def replace(other); end + def self.allocate; end + def self.from(value); end + def to_hash; end + def update(other); end +end +class Faraday::Utils::ParamsHash < Hash + def [](key); end + def []=(key, value); end + def convert_key(key); end + def delete(key); end + def has_key?(key); end + def include?(key); end + def key?(key); end + def member?(key); end + def merge!(params); end + def merge(params); end + def merge_query(query, encoder = nil); end + def replace(other); end + def to_query(encoder = nil); end + def update(params); end +end +class Anonymous_Faraday_Options_8 < Faraday::Options + def bind; end + def bind=(_); end + def boundary; end + def boundary=(_); end + def context; end + def context=(_); end + def oauth; end + def oauth=(_); end + def on_data; end + def on_data=(_); end + def open_timeout; end + def open_timeout=(_); end + def params_encoder; end + def params_encoder=(_); end + def proxy; end + def proxy=(_); end + def read_timeout; end + def read_timeout=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def timeout; end + def timeout=(_); end + def write_timeout; end + def write_timeout=(_); end +end +class Faraday::RequestOptions < Anonymous_Faraday_Options_8 + def []=(key, value); end + def stream_response?; end +end +class Anonymous_Faraday_Options_9 < Faraday::Options + def ca_file; end + def ca_file=(_); end + def ca_path; end + def ca_path=(_); end + def cert_store; end + def cert_store=(_); end + def certificate; end + def certificate=(_); end + def client_cert; end + def client_cert=(_); end + def client_key; end + def client_key=(_); end + def max_version; end + def max_version=(_); end + def min_version; end + def min_version=(_); end + def private_key; end + def private_key=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def verify; end + def verify=(_); end + def verify_depth; end + def verify_depth=(_); end + def verify_mode; end + def verify_mode=(_); end + def version; end + def version=(_); end +end +class Faraday::SSLOptions < Anonymous_Faraday_Options_9 + def disable?; end + def verify?; end +end +class Anonymous_Faraday_Options_10 < Faraday::Options + def password; end + def password=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def uri; end + def uri=(_); end + def user; end + def user=(_); end +end +class Faraday::ProxyOptions < Anonymous_Faraday_Options_10 + def host(*args, &block); end + def host=(*args, &block); end + def password; end + def path(*args, &block); end + def path=(*args, &block); end + def port(*args, &block); end + def port=(*args, &block); end + def scheme(*args, &block); end + def scheme=(*args, &block); end + def self.from(value); end + def user; end + extend Forwardable +end +class Anonymous_Faraday_Options_11 < Faraday::Options + def builder; end + def builder=(_); end + def builder_class; end + def builder_class=(_); end + def headers; end + def headers=(_); end + def parallel_manager; end + def parallel_manager=(_); end + def params; end + def params=(_); end + def proxy; end + def proxy=(_); end + def request; end + def request=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def ssl; end + def ssl=(_); end + def url; end + def url=(_); end +end +class Faraday::ConnectionOptions < Anonymous_Faraday_Options_11 + def builder_class; end + def new_builder(block); end + def request; end + def ssl; end +end +class Anonymous_Faraday_Options_12 < Faraday::Options + def method; end + def method=(_); end + def parallel_manager; end + def parallel_manager=(_); end + def params; end + def params=(_); end + def reason_phrase; end + def reason_phrase=(_); end + def request; end + def request=(_); end + def request_body; end + def request_body=(_); end + def request_headers; end + def request_headers=(_); end + def response; end + def response=(_); end + def response_body; end + def response_body=(_); end + def response_headers; end + def response_headers=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def ssl; end + def ssl=(_); end + def status; end + def status=(_); end + def url; end + def url=(_); end +end +class Faraday::Env < Anonymous_Faraday_Options_12 + def [](key); end + def []=(key, value); end + def body; end + def body=(value); end + def clear_body; end + def current_body; end + def custom_members; end + def in_member_set?(key); end + def inspect; end + def needs_body?; end + def parallel?; end + def params_encoder(*args, &block); end + def parse_body?; end + def self.from(value); end + def self.member_set; end + def success?; end + extend Forwardable +end +class Faraday::Options < Struct + def [](key); end + def clear; end + def deep_dup; end + def delete(key); end + def each; end + def each_key(&block); end + def each_value(&block); end + def empty?; end + def fetch(key, *args); end + def has_key?(key); end + def has_value?(value); end + def inspect; end + def key?(key); end + def keys; end + def merge!(other); end + def merge(other); end + def self.attribute_options; end + def self.fetch_error_class; end + def self.from(value); end + def self.inherited(subclass); end + def self.memoized(key, &block); end + def self.memoized_attributes; end + def self.options(mapping); end + def self.options_for(key); end + def symbolized_key_set; end + def to_hash; end + def update(obj); end + def value?(value); end + def values_at(*keys); end +end +class Faraday::Connection + def adapter(*args, &block); end + def app(*args, &block); end + def build_exclusive_url(url = nil, params = nil, params_encoder = nil); end + def build_request(method); end + def build_url(url = nil, extra_params = nil); end + def builder; end + def close; end + def default_parallel_manager; end + def default_parallel_manager=(arg0); end + def delete(url = nil, params = nil, headers = nil); end + def dup; end + def find_default_proxy; end + def get(url = nil, params = nil, headers = nil); end + def head(url = nil, params = nil, headers = nil); end + def headers; end + def headers=(hash); end + def host(*args, &block); end + def host=(*args, &block); end + def in_parallel(manager = nil); end + def in_parallel?; end + def initialize(url = nil, options = nil); end + def initialize_proxy(url, options); end + def options(*args); end + def parallel_manager; end + def params; end + def params=(hash); end + def patch(url = nil, body = nil, headers = nil, &block); end + def path_prefix(*args, &block); end + def path_prefix=(value); end + def port(*args, &block); end + def port=(*args, &block); end + def post(url = nil, body = nil, headers = nil, &block); end + def proxy; end + def proxy=(new_value); end + def proxy_for_request(url); end + def proxy_from_env(url); end + def put(url = nil, body = nil, headers = nil, &block); end + def request(*args, &block); end + def response(*args, &block); end + def run_request(method, url, body, headers); end + def scheme(*args, &block); end + def scheme=(*args, &block); end + def set_basic_auth(user, password); end + def ssl; end + def support_parallel?(adapter); end + def trace(url = nil, params = nil, headers = nil); end + def url_prefix; end + def url_prefix=(url, encoder = nil); end + def use(*args, &block); end + def with_uri_credentials(uri); end + extend Forwardable +end +class Faraday::AdapterRegistry + def get(name); end + def initialize; end + def set(klass, name = nil); end +end +class Faraday::RackBuilder + def ==(other); end + def [](idx); end + def adapter(klass = nil, *args, &block); end + def adapter_set?; end + def app; end + def assert_index(index); end + def build; end + def build_env(connection, request); end + def build_response(connection, request); end + def delete(handler); end + def ensure_adapter!; end + def handlers; end + def handlers=(arg0); end + def initialize(&block); end + def initialize_dup(original); end + def insert(index, *args, &block); end + def insert_after(index, *args, &block); end + def insert_before(index, *args, &block); end + def is_adapter?(klass); end + def lock!; end + def locked?; end + def raise_if_adapter(klass); end + def raise_if_locked; end + def request(key, *args, &block); end + def response(key, *args, &block); end + def swap(index, *args, &block); end + def to_app; end + def use(klass, *args, &block); end + def use_symbol(mod, key, *args, &block); end +end +class Faraday::RackBuilder::StackLocked < RuntimeError +end +class Faraday::RackBuilder::Handler + def ==(other); end + def build(app = nil); end + def initialize(klass, *args, &block); end + def inspect; end + def klass; end + def name; end +end +module Faraday::EncodeMethods + def encode(params); end + def encode_array(parent, value); end + def encode_hash(parent, value); end + def encode_pair(parent, value); end +end +module Faraday::DecodeMethods + def add_to_context(is_array, context, value, subkey); end + def decode(query); end + def decode_pair(key, value, context); end + def dehash(hash, depth); end + def match_context(context, subkey); end + def new_context(subkey, is_array, context); end + def prepare_context(context, subkey, is_array, last_subkey); end +end +module Faraday::NestedParamsEncoder + def self.array_indices; end + def self.array_indices=(arg0); end + def self.escape(*args, &block); end + def self.sort_params; end + def self.sort_params=(arg0); end + def self.unescape(*args, &block); end + extend Faraday::DecodeMethods + extend Faraday::EncodeMethods +end +module Faraday::FlatParamsEncoder + def self.decode(query); end + def self.encode(params); end + def self.escape(*args, &block); end + def self.sort_params; end + def self.sort_params=(arg0); end + def self.unescape(*args, &block); end +end +class Faraday::Middleware + def app; end + def call(env); end + def close; end + def initialize(app = nil, options = nil); end + def options; end + extend Faraday::MiddlewareRegistry +end +class Faraday::Adapter + def call(env); end + def close; end + def connection(env); end + def initialize(_app = nil, opts = nil, &block); end + def request_timeout(type, options); end + def save_response(env, status, body, headers = nil, reason_phrase = nil); end + extend Faraday::Adapter::Parallelism + extend Faraday::MiddlewareRegistry +end +class Faraday::Adapter::Test < Faraday::Adapter + def call(env); end + def configure; end + def initialize(app, stubs = nil, &block); end + def stubs; end + def stubs=(arg0); end +end +class Faraday::Adapter::Test::Stubs + def delete(path, headers = nil, &block); end + def empty?; end + def get(path, headers = nil, &block); end + def head(path, headers = nil, &block); end + def initialize(strict_mode: nil); end + def match(env); end + def matches?(stack, env); end + def new_stub(request_method, path, headers = nil, body = nil, &block); end + def options(path, headers = nil, &block); end + def patch(path, body = nil, headers = nil, &block); end + def post(path, body = nil, headers = nil, &block); end + def put(path, body = nil, headers = nil, &block); end + def strict_mode=(value); end + def verify_stubbed_calls; end +end +class Faraday::Adapter::Test::Stubs::NotFound < StandardError +end +class Anonymous_Struct_13 < Struct + def block; end + def block=(_); end + def body; end + def body=(_); end + def headers; end + def headers=(_); end + def host; end + def host=(_); end + def path; end + def path=(_); end + def query; end + def query=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def strict_mode; end + def strict_mode=(_); end +end +class Faraday::Adapter::Test::Stub < Anonymous_Struct_13 + def headers_match?(request_headers); end + def matches?(env); end + def params_match?(env); end + def path_match?(request_path, meta); end + def to_s; end +end +module Faraday::Adapter::Parallelism + def inherited(subclass); end + def supports_parallel=(arg0); end + def supports_parallel?; end +end +class Faraday::Request < Anonymous_Struct_14 + def [](key); end + def []=(key, value); end + def headers=(hash); end + def marshal_dump; end + def marshal_load(serialised); end + def params=(hash); end + def self.create(request_method); end + def to_env(connection); end + def url(path, params = nil); end + extend Faraday::MiddlewareRegistry +end +class Faraday::Request::Authorization < Faraday::Middleware + def header_from(type, *params); end + def initialize(app, type, *params); end + def on_request(env); end +end +class Faraday::Request::Instrumentation < Faraday::Middleware + def call(env); end + def initialize(app, options = nil); end +end +class Anonymous_Faraday_Options_15 < Faraday::Options + def instrumenter; end + def instrumenter=(_); 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 Faraday::Request::Instrumentation::Options < Anonymous_Faraday_Options_15 + def instrumenter; end + def name; end +end +class Faraday::Request::Json < Faraday::Middleware + def body?(env); end + def encode(data); end + def match_content_type(env); end + def on_request(env); end + def process_request?(env); end + def request_type(env); end +end +class Faraday::Request::UrlEncoded < Faraday::Middleware + def call(env); end + def match_content_type(env); end + def process_request?(env); end + def request_type(env); end + def self.mime_type; end + def self.mime_type=(arg0); end +end +class Anonymous_Struct_14 < Struct + def body; end + def body=(_); end + def headers; end + def headers=(_); end + def http_method; end + def http_method=(_); end + def options; end + def options=(_); end + def params; end + def params=(_); 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 Faraday::Response + def [](*args, &block); end + def apply_request(request_env); end + def body; end + def env; end + def finish(env); end + def finished?; end + def headers; end + def initialize(env = nil); end + def marshal_dump; end + def marshal_load(env); end + def on_complete(&block); end + def reason_phrase; end + def status; end + def success?; end + def to_hash; end + extend Faraday::MiddlewareRegistry + extend Forwardable +end +class Faraday::Response::Json < Faraday::Middleware + def initialize(app = nil, parser_options: nil, content_type: nil, preserve_raw: nil); end + def on_complete(env); end + def parse(body); end + def parse_response?(env); end + def process_response(env); end + def process_response_type?(env); end + def response_type(env); end +end +module Faraday::Logging +end +class Faraday::Logging::Formatter + def apply_filters(output); end + def debug(*args, &block); end + def dump_body(body); end + def dump_headers(headers); end + def error(*args, &block); end + def fatal(*args, &block); end + def filter(filter_word, filter_replacement); end + def info(*args, &block); end + def initialize(logger:, options:); end + def log_body(type, body); end + def log_body?(type); end + def log_headers(type, headers); end + def log_headers?(type); end + def log_level; end + def pretty_inspect(body); end + def request(env); end + def response(env); end + def warn(*args, &block); end + extend Forwardable +end +class Faraday::Response::Logger < Faraday::Middleware + def call(env); end + def initialize(app, logger = nil, options = nil); end + def on_complete(env); end +end +class Faraday::Response::RaiseError < Faraday::Middleware + def on_complete(env); end + def query_params(env); end + def response_values(env); end +end diff --git a/sorbet/rbi/gems/firebase_dynamic_link.rbi b/sorbet/rbi/gems/firebase_dynamic_link.rbi new file mode 100644 index 0000000..fe6f4dc --- /dev/null +++ b/sorbet/rbi/gems/firebase_dynamic_link.rbi @@ -0,0 +1,21 @@ +# 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/firebase_dynamic_link/all/firebase_dynamic_link.rbi +# +# firebase_dynamic_link-2.0.1 + +module FirebaseDynamicLink + extend Dry::Configurable + extend Dry::Configurable::ClassMethods +end +class FirebaseDynamicLink::InvalidConfig < StandardError +end +class FirebaseDynamicLink::ConnectionError < StandardError +end +class FirebaseDynamicLink::QuotaExceeded < StandardError +end diff --git a/sorbet/rbi/gems/highline.rbi b/sorbet/rbi/gems/highline.rbi new file mode 100644 index 0000000..f7caec4 --- /dev/null +++ b/sorbet/rbi/gems/highline.rbi @@ -0,0 +1,577 @@ +# 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/highline/all/highline.rbi +# +# highline-2.0.3 + +class HighLine + def actual_length(text); end + def agree(yes_or_no_question, character = nil); end + def ask(template_or_question, answer_type = nil, &details); end + def choose(*items, &details); end + def color(string, *colors); end + def color_code(*colors); end + def confirm(question); end + def default_use_color; end + def erase_current_line; end + def get_line(question); end + def get_line_raw_no_echo_mode(question); end + def get_response_character_mode(question); end + def get_response_getc_mode(question); end + def get_response_line_mode(question); end + def ignore_arrow_key; end + def indent(increase = nil, statement = nil, multiline = nil); end + def indent_level; end + def indent_level=(arg0); end + def indent_size; end + def indent_size=(arg0); end + def indentation; end + def initialize(input = nil, output = nil, wrap_at = nil, page_at = nil, indent_size = nil, indent_level = nil); end + def input; end + def key; end + def key=(arg0); end + def last_answer(answers); end + def line_overflow_for_question?(line, question); end + def list(items, mode = nil, option = nil); end + def multi_indent; end + def multi_indent=(arg0); end + def new_scope; end + def newline; end + def output; end + def output_cols; end + def output_erase_char; end + def output_rows; end + def page_at; end + def page_at=(setting); end + def puts(*args); end + def render_statement(statement); end + def reset_use_color; end + def say(statement); end + def say_last_char_or_echo_char(line, question); end + def say_new_line_or_overwrite(question); end + def self.String(s); end + def self.Style(*args); end + def self.agree(*args, &block); end + def self.ask(*args, &block); end + def self.choose(*args, &block); end + def self.color(*args, &block); end + def self.color_code(*args, &block); end + def self.color_scheme; end + def self.color_scheme=(arg0); end + def self.colorize_strings; end + def self.default_instance; end + def self.default_instance=(arg0); end + def self.find_or_create_style(arg); end + def self.find_or_create_style_list(*args); end + def self.reset; end + def self.reset_color_scheme; end + def self.reset_use_color(*args, &block); end + def self.say(*args, &block); end + def self.supports_rgb_color?; end + def self.track_eof=(*args, &block); end + def self.track_eof?(*args, &block); end + def self.uncolor(*args, &block); end + def self.use_color=(*args, &block); end + def self.use_color?(*args, &block); end + def self.using_color_scheme?; end + def shell_style_lambda(menu); end + def terminal; end + def track_eof; end + def track_eof=(arg0); end + def track_eof?; end + def uncolor(string); end + def unique_answers(list); end + def use_color; end + def use_color=(arg0); end + def use_color?; end + def wrap_at; end + def wrap_at=(setting); end + extend HighLine::BuiltinStyles::ClassMethods + extend SingleForwardable + include HighLine::BuiltinStyles + include HighLine::CustomErrors +end +class HighLine::Terminal + def character_mode; end + def get_character; end + def get_line(question, highline); end + def get_line_default(highline); end + def get_line_with_readline(question, highline); end + def initialize(input, output); end + def initialize_system_extensions; end + def input; end + def jruby?; end + def output; end + def raw_no_echo_mode; end + def raw_no_echo_mode_exec; end + def readline_read(question); end + def restore_mode; end + def restore_stty; end + def rubinius?; end + def run_preserving_stty; end + def save_stty; end + def self.get_terminal(input, output); end + def terminal_size; end + def windows?; end +end +module HighLine::CustomErrors +end +class HighLine::CustomErrors::ExplainableError < StandardError + def explanation_key; end +end +class HighLine::CustomErrors::QuestionError < HighLine::CustomErrors::ExplainableError + def explanation_key; end +end +class HighLine::CustomErrors::NotValidQuestionError < HighLine::CustomErrors::ExplainableError + def explanation_key; end +end +class HighLine::CustomErrors::NotInRangeQuestionError < HighLine::CustomErrors::ExplainableError + def explanation_key; end +end +class HighLine::CustomErrors::NoConfirmationQuestionError < HighLine::CustomErrors::ExplainableError + def explanation_key; end +end +class HighLine::CustomErrors::NoAutoCompleteMatch < HighLine::CustomErrors::ExplainableError + def explanation_key; end +end +class HighLine::Question + def above; end + def above=(arg0); end + def answer; end + def answer=(arg0); end + def answer_or_default(answer_string); end + def answer_type; end + def answer_type=(arg0); end + def append_default; end + def ask_on_error_msg; end + def below; end + def below=(arg0); end + def build_responses(message_source = nil); end + def build_responses_new_hash(message_source); end + def case; end + def case=(arg0); end + def change_case(answer_string); end + def character; end + def character=(arg0); end + def check_range; end + def choice_error_str(message_source); end + def choices_complete(answer_string); end + def completion; end + def completion=(arg0); end + def confirm; end + def confirm=(arg0); end + def confirm_question(highline); end + def convert; end + def default; end + def default=(arg0); end + def default_responses_hash; end + def directory; end + def directory=(arg0); end + def echo; end + def echo=(arg0); end + def expected_range; end + def final_response(error); end + def final_responses; end + def first_answer; end + def first_answer=(arg0); end + def first_answer?; end + def format_answer(answer_string); end + def gather; end + def gather=(arg0); end + def get_echo_for_response(response); end + def get_response(highline); end + def get_response_or_default(highline); end + def glob; end + def glob=(arg0); end + def in; end + def in=(arg0); end + def in_range?; end + def initialize(template, answer_type); end + def limit; end + def limit=(arg0); end + def overwrite; end + def overwrite=(arg0); end + def readline; end + def readline=(arg0); end + def remove_whitespace(answer_string); end + def responses; end + def selection; end + def self.build(template_or_question, answer_type = nil, &details); end + def show_question(highline); end + def template; end + def template=(arg0); end + def to_s; end + def valid_answer?; end + def validate; end + def validate=(arg0); end + def verify_match; end + def verify_match=(arg0); end + def whitespace; end + def whitespace=(arg0); end + include HighLine::CustomErrors +end +class HighLine::Question::AnswerConverter + def answer(*args, &block); end + def answer=(*args, &block); end + def answer_type(*args, &block); end + def check_range(*args, &block); end + def choices_complete(*args, &block); end + def convert; end + def convert_by_answer_type; end + def directory(*args, &block); end + def initialize(question); end + def to_array; end + def to_file; end + def to_float; end + def to_integer; end + def to_pathname; end + def to_proc; end + def to_regexp; end + def to_string; end + def to_symbol; end + extend Forwardable +end +class HighLine::QuestionAsker + def answer_matches_regex(answer); end + def ask_once; end + def explain_error(explanation_key); end + def gather_answers; end + def gather_answers_based_on_type; end + def gather_hash; end + def gather_integer; end + def gather_regexp; end + def gather_with_array; end + def initialize(question, highline); end + def question; end + include HighLine::CustomErrors +end +class HighLine::Menu < HighLine::Question + def add_item(item); end + def all_items; end + def build_item(*args); end + def choice(name, help = nil, text = nil, &action); end + def choices(*names, &action); end + def decorate_index(index); end + def decorate_item(text, ix); end + def find_item_from_selection(items, selection); end + def flow; end + def flow=(arg0); end + def gather_selected(highline_context, selections, details = nil); end + def get_item_by_letter(items, selection); end + def get_item_by_number(items, selection); end + def header; end + def header=(arg0); end + def help(topic, help); end + def hidden(name, help = nil, &action); end + def index; end + def index=(style); end + def index_color; end + def index_color=(arg0); end + def index_suffix; end + def index_suffix=(arg0); end + def init_help; end + def initialize; end + def layout; end + def layout=(new_layout); end + def list_option; end + def list_option=(arg0); end + def map_items_by_index; end + def map_items_by_name; end + def mark_for_decoration(text, ix); end + def nil_on_handled; end + def nil_on_handled=(arg0); end + def options; end + def parse_list; end + def prompt; end + def prompt=(arg0); end + def select(highline_context, selection, details = nil); end + def select_by; end + def select_by=(arg0); end + def self.index_color; end + def self.index_color=(arg0); end + def shell; end + def shell=(arg0); end + def show_default_if_any; end + def to_ary; end + def to_s; end + def update_responses; end + def value_for_array_selections(items, selections, details); end + def value_for_hash_selections(items, selections, details); end + def value_for_selected_item(item, details); end +end +class HighLine::Menu::Item + def action; end + def help; end + def initialize(name, attributes); end + def item_help; end + def name; end + def text; end +end +class HighLine::ColorScheme + def [](color_tag); end + def []=(color_tag, constants); end + def definition(color_tag); end + def include?(color_tag); end + def initialize(h = nil); end + def keys; end + def load_from_hash(h); end + def to_constant(v); end + def to_hash; end + def to_symbol(t); end +end +class HighLine::SampleColorScheme < HighLine::ColorScheme + def initialize(_h = nil); end +end +class HighLine::Style + def blue; end + def bright; end + def builtin; end + def builtin=(arg0); end + def code; end + def color(string); end + def create_bright_variant(variant_name); end + def dup; end + def find_style(name); end + def green; end + def initialize(defn = nil); end + def light; end + def list; end + def name; end + def on; end + def red; end + def rgb; end + def rgb=(arg0); end + def self.ansi_rgb_to_hex(ansi_number); end + def self.clear_index; end + def self.code_index; end + def self.index(style); end + def self.list; end + def self.rgb(*colors); end + def self.rgb_hex(*colors); end + def self.rgb_number(*parts); end + def self.rgb_parts(hex); end + def self.uncolor(string); end + def to_hash; end + def variant(new_name, options = nil); end +end +module HighLine::Wrapper + def self.actual_length(string_with_escapes); end + def self.wrap(text, wrap_at); end +end +class HighLine::Paginator + def continue_paging?; end + def highline; end + def initialize(highline); end + def page_print(text); end +end +class HighLine::TemplateRenderer + def answer(*args, &block); end + def answer_type(*args, &block); end + def color(*args, &block); end + def header(*args, &block); end + def highline; end + def initialize(template, source, highline); end + def key(*args, &block); end + def list(*args, &block); end + def menu; end + def method_missing(method, *args); end + def prompt(*args, &block); end + def render; end + def self.const_missing(name); end + def source; end + def template; end + extend Forwardable +end +class HighLine::Statement + def format_statement; end + def highline; end + def initialize(source, highline); end + def render_template; end + def self.const_missing(constant); end + def source; end + def statement; end + def stringfy(template_string); end + def template; end + def template_string; end + def to_s; end +end +class HighLine::List + def build; end + def col_down; end + def col_down_mode; end + def cols; end + def cols=(cols); end + def initialize(items, options = nil); end + def items; end + def items_sliced_by_cols; end + def items_sliced_by_rows; end + def list; end + def row_count; end + def row_join_str_size; end + def row_join_string; end + def row_join_string=(arg0); end + def slice_by_cols; end + def slice_by_rows; end + def stringfy(row); end + def to_a; end + def to_s; end + def transpose; end + def transpose_mode; end +end +class HighLine::ListRenderer + def actual_length(text); end + def actual_lengths_for(line); end + def col_count; end + def col_count_calculate; end + def get_col_widths(lines); end + def get_row_widths(lines); end + def get_segment_widths(lines); end + def highline; end + def initialize(items, mode = nil, option = nil, highline); end + def inside_line_size_limit?(widths); end + def items; end + def items_max_length; end + def line_size_limit; end + def list_columns_across_mode; end + def list_columns_down_mode; end + def list_default_mode; end + def list_inline_mode; end + def list_uneven_columns_down_mode; end + def list_uneven_columns_mode(list = nil); end + def max_length(items); end + def mode; end + def option; end + def pad_char; end + def pad_uneven_rows(list, widths); end + def render; end + def render_list_items(items); end + def right_pad_field(field, width); end + def right_pad_row(row, widths); end + def right_padded_items; end + def row_count; end + def row_join_str_size; end + def row_join_string; end + def row_join_string=(arg0); end + def row_to_s(row); end + def stringfy_list(list); end + def transpose(lines); end +end +module HighLine::BuiltinStyles + def self.included(base); end +end +module HighLine::BuiltinStyles::ClassMethods + def const_missing(name); end +end +class HighLine::Terminal::IOConsole < HighLine::Terminal + def get_character; end + def raw_no_echo_mode; end + def restore_mode; end + def terminal_size; end +end +module HighLine::StringExtensions + def self.define_builtin_style_methods(base); end + def self.define_style_support_methods(base); end + def self.included(base); end +end +class HighLine::String < String + def black; end + def blink; end + def blue; end + def bold; end + def bright_black; end + def bright_blue; end + def bright_cyan; end + def bright_gray; end + def bright_green; end + def bright_grey; end + def bright_magenta; end + def bright_none; end + def bright_red; end + def bright_white; end + def bright_yellow; end + def clear; end + def color(*args); end + def concealed; end + def cyan; end + def dark; end + def foreground(*args); end + def gray; end + def green; end + def grey; end + def light_black; end + def light_blue; end + def light_cyan; end + def light_gray; end + def light_green; end + def light_grey; end + def light_magenta; end + def light_none; end + def light_red; end + def light_white; end + def light_yellow; end + def magenta; end + def method_missing(method, *_args); end + def none; end + def on(arg); end + def on_black; end + def on_blue; end + def on_bright_black; end + def on_bright_blue; end + def on_bright_cyan; end + def on_bright_gray; end + def on_bright_green; end + def on_bright_grey; end + def on_bright_magenta; end + def on_bright_none; end + def on_bright_red; end + def on_bright_white; end + def on_bright_yellow; end + def on_cyan; end + def on_gray; end + def on_green; end + def on_grey; end + def on_light_black; end + def on_light_blue; end + def on_light_cyan; end + def on_light_gray; end + def on_light_green; end + def on_light_grey; end + def on_light_magenta; end + def on_light_none; end + def on_light_red; end + def on_light_white; end + def on_light_yellow; end + def on_magenta; end + def on_none; end + def on_red; end + def on_rgb(*colors); end + def on_white; end + def on_yellow; end + def red; end + def reset; end + def respond_to_missing?(method_name, include_private = nil); end + def reverse; end + def rgb(*colors); end + def setup_color_code(*colors); end + def uncolor; end + def underline; end + def underscore; end + def white; end + def yellow; end + include HighLine::StringExtensions +end +module Kernel + def agree(*args, &block); end + def ask(*args, &block); end + def choose(*args, &block); end + def say(*args, &block); end + extend Forwardable +end +class Object < BasicObject + def or_ask(*args, &details); end +end diff --git a/sorbet/rbi/gems/method_source.rbi b/sorbet/rbi/gems/method_source.rbi new file mode 100644 index 0000000..92cdecd --- /dev/null +++ b/sorbet/rbi/gems/method_source.rbi @@ -0,0 +1,64 @@ +# 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/msgpack.rbi b/sorbet/rbi/gems/msgpack.rbi new file mode 100644 index 0000000..0add510 --- /dev/null +++ b/sorbet/rbi/gems/msgpack.rbi @@ -0,0 +1,196 @@ +# 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/msgpack/all/msgpack.rbi +# +# msgpack-1.5.2 + +module MessagePack + def dump(v, io = nil, options = nil); end + def load(src, param = nil); end + def pack(v, io = nil, options = nil); end + def self.dump(v, io = nil, options = nil); end + def self.load(src, param = nil); end + def self.pack(v, io = nil, options = nil); end + def self.unpack(src, param = nil); end + def unpack(src, param = nil); end +end +class MessagePack::Buffer + def <<(arg0); end + def clear; end + def close; end + def empty?; end + def flush; end + def initialize(*arg0); end + def io; end + def read(*arg0); end + def read_all(*arg0); end + def size; end + def skip(arg0); end + def skip_all(arg0); end + def to_a; end + def to_s; end + def to_str; end + def write(arg0); end + def write_to(arg0); end +end +class MessagePack::Packer + def buffer; end + def clear; end + def compatibility_mode?; end + def empty?; end + def flush; end + def full_pack; end + def initialize(*arg0); end + def pack(arg0); end + def register_type(*arg0); end + def registered_types; end + def registered_types_internal; end + def reset; end + def size; end + def to_a; end + def to_s; end + def to_str; end + def type_registered?(klass_or_type); end + def write(arg0); end + def write_array(arg0); end + def write_array_header(arg0); end + def write_bin(arg0); end + def write_bin_header(arg0); end + def write_ext(arg0, arg1); end + def write_extension(arg0); end + def write_false; end + def write_float(arg0); end + def write_float32(arg0); end + def write_hash(arg0); end + def write_int(arg0); end + def write_map_header(arg0); end + def write_nil; end + def write_string(arg0); end + def write_symbol(arg0); end + def write_to(arg0); end + def write_true; end +end +class MessagePack::Unpacker + def allow_unknown_ext?; end + def buffer; end + def each; end + def feed(arg0); end + def feed_each(arg0); end + def feed_reference(arg0); end + def freeze?; end + def full_unpack; end + def initialize(*arg0); end + def read; end + def read_array_header; end + def read_map_header; end + def register_type(*arg0); end + def registered_types; end + def registered_types_internal; end + def reset; end + def skip; end + def skip_nil; end + def symbolize_keys?; end + def type_registered?(klass_or_type); end + def unpack; end +end +class MessagePack::Factory + def dump(v, *rest); end + def dup; end + def freeze; end + def initialize(*arg0); end + def load(src, param = nil); end + def pack(v, *rest); end + def packer(*arg0); end + def pool(size = nil, **options); end + def register_type(*arg0); end + def registered_types(selector = nil); end + def registered_types_internal; end + def type_registered?(klass_or_type, selector = nil); end + def unpack(src, param = nil); end + def unpacker(*arg0); end +end +class MessagePack::ExtensionValue < Struct + def payload; end + def payload=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def to_msgpack_with_packer(packer); end + def type; end + def type=(_); end + include MessagePack::CoreExt +end +class MessagePack::Factory::Pool + def dump(object); end + def initialize(factory, size, options = nil); end + def load(data); end +end +class MessagePack::Factory::Pool::AbstractPool + def checkin(member); end + def checkout; end + def initialize(size, &block); end +end +class MessagePack::Factory::Pool::PackerPool < MessagePack::Factory::Pool::AbstractPool + def reset(packer); end +end +class MessagePack::Factory::Pool::UnpackerPool < MessagePack::Factory::Pool::AbstractPool + def reset(unpacker); end +end +class Symbol + def self.all_symbols; end + def to_msgpack_ext; end + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +module MessagePack::CoreExt + def to_msgpack(packer_or_io = nil); end +end +class NilClass + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class TrueClass + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class FalseClass + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class Float < Numeric + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class String + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class Array + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class Hash + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class Integer < Numeric + def to_msgpack_with_packer(packer); end + include MessagePack::CoreExt +end +class MessagePack::Timestamp + def ==(other); end + def initialize(sec, nsec); end + def nsec; end + def sec; end + def self.from_msgpack_ext(data); end + def self.to_msgpack_ext(sec, nsec); end + def to_msgpack_ext; end +end +module MessagePack::Time +end diff --git a/sorbet/rbi/gems/parallel.rbi b/sorbet/rbi/gems/parallel.rbi new file mode 100644 index 0000000..ce93524 --- /dev/null +++ b/sorbet/rbi/gems/parallel.rbi @@ -0,0 +1,86 @@ +# 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/parlour.rbi b/sorbet/rbi/gems/parlour.rbi new file mode 100644 index 0000000..567c65f --- /dev/null +++ b/sorbet/rbi/gems/parlour.rbi @@ -0,0 +1,840 @@ +# 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/parlour/all/parlour.rbi +# +# parlour-5.0.0 + +module Parlour +end +module Parlour::Debugging + def self.debug_mode=(*args, &blk); end + def self.debug_mode?(&blk); end + def self.debug_puts(arg0, arg1, &blk); end + def self.name_for_debug_caller(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +module Parlour::Debugging::Tree + def self.begin(*args, &blk); end + def self.end(*args, &blk); end + def self.here(*args, &blk); end + def self.line_prefix; end + def self.text_prefix; end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +module Kernel +end +class Parlour::Plugin + def generate(*args, &blk); end + def initialize(*args, &blk); end + def self.inherited(arg0, &blk); end + def self.registered_plugins(&blk); end + def self.run_plugins(*args, &blk); end + def strictness(*args, &blk); end + def strictness=(arg0); end + extend T::Helpers + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +module Parlour::Types +end +class Parlour::Types::Type + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def hash; end + def initialize(*args, &blk); end + def self.to_type(*args, &blk); end + def to_type(*args, &blk); end + extend T::Helpers + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::Types::Raw < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def str(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Nilable < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Union < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def types(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Intersection < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def types(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Tuple < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def types(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Generic < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def type(*args, &blk); end + def type_params(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::SingleElementCollection < Parlour::Types::Type + def collection_name(*args, &blk); end + def describe(*args, &blk); end + def element(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Array < Parlour::Types::SingleElementCollection + def ==(*args, &blk); end + def collection_name(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Set < Parlour::Types::SingleElementCollection + def ==(*args, &blk); end + def collection_name(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Range < Parlour::Types::SingleElementCollection + def ==(*args, &blk); end + def collection_name(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Enumerable < Parlour::Types::SingleElementCollection + def ==(*args, &blk); end + def collection_name(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Enumerator < Parlour::Types::SingleElementCollection + def ==(*args, &blk); end + def collection_name(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Hash < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def key(*args, &blk); end + def value(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Record < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def keys_to_types(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Class < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Boolean < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Self < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Untyped < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Proc < Parlour::Types::Type + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbi(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def parameters(*args, &blk); end + def return_type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::Types::Proc::Parameter + def ==(*args, &blk); end + def default(*args, &blk); end + def initialize(*args, &blk); end + def name(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::Options + def break_params(*args, &blk); end + def indented(*args, &blk); end + def initialize(*args, &blk); end + def sort_namespaces(*args, &blk); end + def tab_size(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::TypedObject + def add_comment(*args, &blk); end + def add_comments(*args, &blk); end + def comments(*args, &blk); end + def describe(*args, &blk); end + def generate_comments(*args, &blk); end + def generated_by(*args, &blk); end + def initialize(*args, &blk); end + def name(*args, &blk); end + extend T::Helpers + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::Generator + def current_plugin(*args, &blk); end + def current_plugin=(arg0); end + def initialize(*args, &blk); end + def options(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator < Parlour::Generator + def initialize(**hash); end + def rbi(*args, &blk); end + def root(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Parameter + def ==(*args, &blk); end + def default(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def initialize(*args, &blk); end + def kind(*args, &blk); end + def name(*args, &blk); end + def name_without_kind(*args, &blk); end + def to_def_param(*args, &blk); end + def to_sig_param(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::RbiObject < Parlour::TypedObject + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def generator(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::TypeAlias < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Method < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def abstract(*args, &blk); end + def class_method(*args, &blk); end + def describe(*args, &blk); end + def final(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_definition(*args, &blk); end + def generate_rbi(*args, &blk); end + def implementation(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def overridable(*args, &blk); end + def override(*args, &blk); end + def parameters(*args, &blk); end + def qualifiers(*args, &blk); end + def return_type(*args, &blk); end + def type_parameters(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::Attribute < Parlour::RbiGenerator::Method + def ==(*args, &blk); end + def class_attribute(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_definition(*args, &blk); end + def initialize(*args, &blk); end + def kind(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Arbitrary < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def code(*args, &blk); end + def code=(arg0); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Include < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Extend < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Constant < Parlour::RbiGenerator::RbiObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def eigen_constant; end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def value(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbiGenerator::Namespace < Parlour::RbiGenerator::RbiObject + def add_comment_to_next_child(*args, &blk); end + def aliases(*args, &blk); end + def children(*args, &blk); end + def constants(*args, &blk); end + def create_arbitrary(code:, &block); end + def create_attr(*args, &blk); end + def create_attr_accessor(*args, &blk); end + def create_attr_reader(*args, &blk); end + def create_attr_writer(*args, &blk); end + def create_attribute(*args, &blk); end + def create_class(*args, &blk); end + def create_constant(*args, &blk); end + def create_enum_class(*args, &blk); end + def create_extend(*args, &blk); end + def create_extends(*args, &blk); end + def create_include(*args, &blk); end + def create_includes(*args, &blk); end + def create_method(*args, &blk); end + def create_module(*args, &blk); end + def create_struct_class(*args, &blk); end + def create_type_alias(*args, &blk); end + def describe(*args, &blk); end + def extends(*args, &blk); end + def final(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_body(*args, &blk); end + def generate_rbi(*args, &blk); end + def includes(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def move_next_comments(*args, &blk); end + def path(*args, &blk); end + def sealed(*args, &blk); end + def type_aliases(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::ModuleNamespace < Parlour::RbiGenerator::Namespace + def abstract(*args, &blk); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def interface(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::ClassNamespace < Parlour::RbiGenerator::Namespace + def abstract(*args, &blk); end + def describe(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_rbi(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def superclass(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::EnumClassNamespace < Parlour::RbiGenerator::ClassNamespace + def enums(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def generate_body(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::StructProp + def ==(*args, &blk); end + def array(*args, &blk); end + def default(*args, &blk); end + def dont_store(*args, &blk); end + def enum(*args, &blk); end + def factory(*args, &blk); end + def foreign(*args, &blk); end + def generalize_from_rbi!(*args, &blk); end + def immutable(*args, &blk); end + def initialize(*args, &blk); end + def name(*args, &blk); end + def optional(*args, &blk); end + def override(*args, &blk); end + def redaction(*args, &blk); end + def to_prop_call(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbiGenerator::StructClassNamespace < Parlour::RbiGenerator::ClassNamespace + def generalize_from_rbi!(*args, &blk); end + def generate_body(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def props(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::DetachedRbiGenerator < Parlour::RbiGenerator + def current_plugin(*args, &blk); end + def detached!(*args, &blk); end + def options(*args, &blk); end + def rbi(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator < Parlour::Generator + def initialize(**hash); end + def rbs(*args, &blk); end + def root(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::RbsObject < Parlour::TypedObject + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def generator(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::TypeAlias < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::Namespace < Parlour::RbsGenerator::RbsObject + def add_comment_to_next_child(*args, &blk); end + def aliases(*args, &blk); end + def children(*args, &blk); end + def constants(*args, &blk); end + def create_arbitrary(code:, &block); end + def create_attr(*args, &blk); end + def create_attr_accessor(*args, &blk); end + def create_attr_reader(*args, &blk); end + def create_attr_writer(*args, &blk); end + def create_attribute(*args, &blk); end + def create_class(*args, &blk); end + def create_constant(*args, &blk); end + def create_extend(*args, &blk); end + def create_extends(*args, &blk); end + def create_include(*args, &blk); end + def create_includes(*args, &blk); end + def create_interface(*args, &blk); end + def create_method(*args, &blk); end + def create_module(*args, &blk); end + def create_type_alias(*args, &blk); end + def describe(*args, &blk); end + def extends(*args, &blk); end + def generate_body(*args, &blk); end + def generate_rbs(*args, &blk); end + def includes(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def move_next_comments(*args, &blk); end + def path(*args, &blk); end + def type_aliases(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::Method < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def class_method(*args, &blk); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def signatures(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::Arbitrary < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def code(*args, &blk); end + def code=(arg0); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::Attribute < Parlour::RbsGenerator::Method + def ==(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def kind(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::Block + def ==(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def required(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::ClassNamespace < Parlour::RbsGenerator::Namespace + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def superclass(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::Constant < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::Extend < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::Include < Parlour::RbsGenerator::RbsObject + def ==(*args, &blk); end + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def merge_into_self(*args, &blk); end + def mergeable?(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +class Parlour::RbsGenerator::MethodSignature + def ==(*args, &blk); end + def block(*args, &blk); end + def generate_rbs(*args, &blk); end + def initialize(*args, &blk); end + def parameters(*args, &blk); end + def return_type(*args, &blk); end + def type_parameters(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::ModuleNamespace < Parlour::RbsGenerator::Namespace + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::InterfaceNamespace < Parlour::RbsGenerator::Namespace + def describe(*args, &blk); end + def generate_rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::RbsGenerator::Parameter + def ==(*args, &blk); end + def initialize(*args, &blk); end + def kind(*args, &blk); end + def name(*args, &blk); end + def name_without_kind(*args, &blk); end + def required(*args, &blk); end + def to_rbs_param(*args, &blk); end + def type(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::DetachedRbsGenerator < Parlour::RbsGenerator + def current_plugin(*args, &blk); end + def detached!(*args, &blk); end + def options(*args, &blk); end + def rbs(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks +end +module Parlour::Conversion +end +class Parlour::Conversion::Converter + def add_warning(*args, &blk); end + def initialize; end + def warnings(*args, &blk); end + extend T::Helpers + extend T::InterfaceWrapper::Helpers + extend T::Private::Abstract::Hooks + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::Conversion::RbiToRbs < Parlour::Conversion::Converter + def convert_all(*args, &blk); end + def convert_object(*args, &blk); end + def initialize(*args, &blk); end + def rbs_gen(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::ConflictResolver + def all_eql?(*args, &blk); end + def deduplicate_mixins_of_name(*args, &blk); end + def merge_strategy(*args, &blk); end + def resolve_conflicts(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::ParseError < StandardError + def buffer(*args, &blk); end + def initialize(buffer, range); end + def range(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::TypeParser + def ast(*args, &blk); end + def ast=(arg0); end + def body_has_modifier?(*args, &blk); end + def body_includes_and_extends(*args, &blk); end + def constant_names(*args, &blk); end + def generator(*args, &blk); end + def generator=(arg0); end + def initialize(*args, &blk); end + def node_to_s(*args, &blk); end + def parse_all(*args, &blk); end + def parse_err(*args, &blk); end + def parse_method_into_methods(*args, &blk); end + def parse_node_to_type(*args, &blk); end + def parse_path_to_object(*args, &blk); end + def parse_sig_into_methods(*args, &blk); end + def parse_sig_into_sig(*args, &blk); end + def previous_sibling_sig_node?(*args, &blk); end + def self.from_source(*args, &blk); end + def self.parse_single_type(*args, &blk); end + def sig_node?(*args, &blk); end + def unknown_node_errors(*args, &blk); end + def warning(*args, &blk); end + def zip_by(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::TypeParser::NodePath + def child(*args, &blk); end + def indices(*args, &blk); end + def initialize(*args, &blk); end + def parent(*args, &blk); end + def sibling(*args, &blk); end + def traverse(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end +class Parlour::TypeParser::IntermediateSig < T::Struct + def __t_props_generated_deserialize(*args); end + def __t_props_generated_serialize(*args); end + def abstract; end + def abstract=(val); end + def final; end + def final=(val); end + def overridable; end + def overridable=(val); end + def override; end + def override=(val); end + def params; end + def params=(val); end + def return_type; end + def return_type=(val); end + def self.inherited(s); end + def type_parameters; end + def type_parameters=(val); end + extend T::Props::ClassMethods + extend T::Props::Plugin::ClassMethods + extend T::Props::Plugin::ClassMethods + extend T::Props::Plugin::ClassMethods + extend T::Props::Plugin::ClassMethods + extend T::Props::Plugin::ClassMethods + extend T::Props::Serializable::ClassMethods +end +module Parlour::TypeLoader + def self.load_file(*args, &blk); end + def self.load_project(*args, &blk); end + def self.load_source(*args, &blk); end + extend T::Private::Methods::MethodHooks + extend T::Private::Methods::SingletonMethodHooks + extend T::Sig +end diff --git a/sorbet/rbi/gems/parser.rbi b/sorbet/rbi/gems/parser.rbi new file mode 100644 index 0000000..9be147c --- /dev/null +++ b/sorbet/rbi/gems/parser.rbi @@ -0,0 +1,1977 @@ +# 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 + def self.warn_syntax_deviation(feature, version); end +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::Ruby30 < Parser::Base + def _reduce_1(val, _values, result); end + 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_109(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_113(val, _values, result); end + def _reduce_114(val, _values, result); end + def _reduce_115(val, _values, result); end + def _reduce_116(val, _values, result); end + def _reduce_117(val, _values, result); end + def _reduce_118(val, _values, result); end + def _reduce_119(val, _values, result); end + def _reduce_12(val, _values, result); end + def _reduce_120(val, _values, result); end + def _reduce_121(val, _values, result); end + def _reduce_123(val, _values, result); end + def _reduce_124(val, _values, result); end + def _reduce_125(val, _values, result); end + def _reduce_13(val, _values, result); end + def _reduce_131(val, _values, result); end + def _reduce_133(val, _values, result); end + def _reduce_134(val, _values, result); end + def _reduce_135(val, _values, result); end + def _reduce_14(val, _values, result); end + def _reduce_15(val, _values, result); end + def _reduce_16(val, _values, result); end + def _reduce_18(val, _values, result); end + def _reduce_19(val, _values, result); end + def _reduce_2(val, _values, result); end + def _reduce_20(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_236(val, _values, result); end + def _reduce_237(val, _values, result); end + def _reduce_238(val, _values, result); end + def _reduce_239(val, _values, result); end + def _reduce_24(val, _values, result); end + def _reduce_240(val, _values, result); end + def _reduce_241(val, _values, result); end + def _reduce_242(val, _values, result); end + def _reduce_243(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_247(val, _values, result); end + def _reduce_248(val, _values, result); end + def _reduce_249(val, _values, result); end + def _reduce_25(val, _values, result); end + def _reduce_250(val, _values, result); end + def _reduce_251(val, _values, result); end + def _reduce_252(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_263(val, _values, result); end + def _reduce_264(val, _values, result); end + def _reduce_266(val, _values, result); end + def _reduce_267(val, _values, result); end + def _reduce_268(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_272(val, _values, result); end + def _reduce_275(val, _values, result); end + def _reduce_276(val, _values, result); end + def _reduce_277(val, _values, result); end + def _reduce_278(val, _values, result); end + def _reduce_279(val, _values, result); end + def _reduce_28(val, _values, result); end + def _reduce_280(val, _values, result); end + def _reduce_281(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_29(val, _values, result); end + def _reduce_290(val, _values, result); end + def _reduce_291(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_3(val, _values, result); end + def _reduce_30(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_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_327(val, _values, result); end + def _reduce_329(val, _values, result); end + def _reduce_33(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_334(val, _values, result); end + def _reduce_335(val, _values, result); end + def _reduce_336(val, _values, result); end + def _reduce_337(val, _values, result); end + def _reduce_338(val, _values, result); end + def _reduce_339(val, _values, result); end + def _reduce_34(val, _values, result); end + def _reduce_340(val, _values, result); end + def _reduce_341(val, _values, result); end + def _reduce_342(val, _values, result); end + def _reduce_343(val, _values, result); end + def _reduce_344(val, _values, result); end + def _reduce_345(val, _values, result); end + def _reduce_346(val, _values, result); end + def _reduce_347(val, _values, result); end + def _reduce_348(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_352(val, _values, result); end + def _reduce_353(val, _values, result); end + def _reduce_356(val, _values, result); end + def _reduce_360(val, _values, result); end + def _reduce_362(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_37(val, _values, result); end + def _reduce_370(val, _values, result); end + def _reduce_371(val, _values, result); end + def _reduce_372(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_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_381(val, _values, result); end + def _reduce_382(val, _values, result); end + def _reduce_383(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_391(val, _values, result); end + def _reduce_392(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_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_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_42(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_428(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_432(val, _values, result); end + def _reduce_433(val, _values, result); end + def _reduce_434(val, _values, result); end + def _reduce_435(val, _values, result); end + def _reduce_436(val, _values, result); end + def _reduce_437(val, _values, result); end + def _reduce_438(val, _values, result); end + def _reduce_439(val, _values, result); end + def _reduce_44(val, _values, result); end + def _reduce_440(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_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_451(val, _values, result); end + def _reduce_452(val, _values, result); end + def _reduce_453(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_461(val, _values, result); end + def _reduce_463(val, _values, result); end + def _reduce_465(val, _values, result); end + def _reduce_466(val, _values, result); end + def _reduce_468(val, _values, result); end + def _reduce_469(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_476(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_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_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_50(val, _values, result); end + def _reduce_500(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_51(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_518(val, _values, result); end + def _reduce_519(val, _values, result); end + def _reduce_52(val, _values, result); end + def _reduce_520(val, _values, result); end + def _reduce_521(val, _values, result); end + def _reduce_525(val, _values, result); end + def _reduce_526(val, _values, result); end + def _reduce_53(val, _values, result); end + def _reduce_535(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_54(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_547(val, _values, result); end + def _reduce_549(val, _values, result); end + def _reduce_55(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_560(val, _values, result); end + def _reduce_561(val, _values, result); end + def _reduce_562(val, _values, result); end + def _reduce_563(val, _values, result); end + def _reduce_564(val, _values, result); end + def _reduce_565(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_569(val, _values, result); end + def _reduce_570(val, _values, result); end + def _reduce_571(val, _values, result); end + def _reduce_572(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_579(val, _values, result); end + def _reduce_580(val, _values, result); end + def _reduce_581(val, _values, result); end + def _reduce_582(val, _values, result); end + def _reduce_583(val, _values, result); end + def _reduce_584(val, _values, result); end + def _reduce_585(val, _values, result); end + def _reduce_586(val, _values, result); end + def _reduce_587(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_593(val, _values, result); end + def _reduce_594(val, _values, result); end + def _reduce_595(val, _values, result); end + def _reduce_596(val, _values, result); end + def _reduce_597(val, _values, result); end + def _reduce_598(val, _values, result); end + def _reduce_599(val, _values, result); end + def _reduce_6(val, _values, result); end + def _reduce_60(val, _values, result); end + def _reduce_600(val, _values, result); end + def _reduce_601(val, _values, result); end + def _reduce_602(val, _values, result); end + def _reduce_603(val, _values, result); end + def _reduce_604(val, _values, result); end + def _reduce_605(val, _values, result); end + def _reduce_606(val, _values, result); end + def _reduce_607(val, _values, result); end + def _reduce_608(val, _values, result); end + def _reduce_609(val, _values, result); end + def _reduce_61(val, _values, result); end + def _reduce_610(val, _values, result); end + def _reduce_611(val, _values, result); end + def _reduce_612(val, _values, result); end + def _reduce_613(val, _values, result); end + def _reduce_614(val, _values, result); end + def _reduce_615(val, _values, result); end + def _reduce_616(val, _values, result); end + def _reduce_617(val, _values, result); end + def _reduce_618(val, _values, result); end + def _reduce_619(val, _values, result); end + def _reduce_62(val, _values, result); end + def _reduce_621(val, _values, result); end + def _reduce_622(val, _values, result); end + def _reduce_623(val, _values, result); end + def _reduce_624(val, _values, result); end + def _reduce_626(val, _values, result); end + def _reduce_627(val, _values, result); end + def _reduce_628(val, _values, result); end + def _reduce_629(val, _values, result); end + def _reduce_63(val, _values, result); end + def _reduce_630(val, _values, result); end + def _reduce_631(val, _values, result); end + def _reduce_632(val, _values, result); end + def _reduce_633(val, _values, result); end + def _reduce_634(val, _values, result); end + def _reduce_635(val, _values, result); end + def _reduce_636(val, _values, result); end + def _reduce_637(val, _values, result); end + def _reduce_638(val, _values, result); end + def _reduce_639(val, _values, result); end + def _reduce_64(val, _values, result); end + def _reduce_640(val, _values, result); end + def _reduce_641(val, _values, result); end + def _reduce_642(val, _values, result); end + def _reduce_643(val, _values, result); end + def _reduce_644(val, _values, result); end + def _reduce_645(val, _values, result); end + def _reduce_646(val, _values, result); end + def _reduce_647(val, _values, result); end + def _reduce_648(val, _values, result); end + def _reduce_649(val, _values, result); end + def _reduce_650(val, _values, result); end + def _reduce_651(val, _values, result); end + def _reduce_652(val, _values, result); end + def _reduce_653(val, _values, result); end + def _reduce_655(val, _values, result); end + def _reduce_656(val, _values, result); end + def _reduce_657(val, _values, result); end + def _reduce_658(val, _values, result); end + def _reduce_659(val, _values, result); end + def _reduce_660(val, _values, result); end + def _reduce_661(val, _values, result); end + def _reduce_662(val, _values, result); end + def _reduce_663(val, _values, result); end + def _reduce_664(val, _values, result); end + def _reduce_665(val, _values, result); end + def _reduce_666(val, _values, result); end + def _reduce_667(val, _values, result); end + def _reduce_668(val, _values, result); end + def _reduce_669(val, _values, result); end + def _reduce_672(val, _values, result); end + def _reduce_673(val, _values, result); end + def _reduce_674(val, _values, result); end + def _reduce_675(val, _values, result); end + def _reduce_676(val, _values, result); end + def _reduce_677(val, _values, result); end + def _reduce_678(val, _values, result); end + def _reduce_679(val, _values, result); end + def _reduce_68(val, _values, result); end + def _reduce_680(val, _values, result); end + def _reduce_683(val, _values, result); end + def _reduce_684(val, _values, result); end + def _reduce_687(val, _values, result); end + def _reduce_688(val, _values, result); end + def _reduce_689(val, _values, result); end + def _reduce_69(val, _values, result); end + def _reduce_691(val, _values, result); end + def _reduce_692(val, _values, result); end + def _reduce_694(val, _values, result); end + def _reduce_695(val, _values, result); end + def _reduce_696(val, _values, result); end + def _reduce_697(val, _values, result); end + def _reduce_698(val, _values, result); end + def _reduce_699(val, _values, result); end + def _reduce_7(val, _values, result); end + def _reduce_70(val, _values, result); end + def _reduce_712(val, _values, result); end + def _reduce_713(val, _values, result); end + def _reduce_718(val, _values, result); end + def _reduce_719(val, _values, result); end + def _reduce_72(val, _values, result); end + def _reduce_720(val, _values, result); end + def _reduce_724(val, _values, result); end + def _reduce_728(val, _values, result); end + def _reduce_73(val, _values, result); end + def _reduce_74(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_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_84(val, _values, result); end + def _reduce_85(val, _values, result); end + def _reduce_86(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_98(val, _values, result); end + def _reduce_99(val, _values, result); end + def _reduce_none(val, _values, result); end + def default_encoding; end + def endless_method_name(name_t); end + def local_pop; end + def local_push; end + def try_declare_numparam(node); end + def version; end +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/pry.rbi b/sorbet/rbi/gems/pry.rbi new file mode 100644 index 0000000..cc7c02f --- /dev/null +++ b/sorbet/rbi/gems/pry.rbi @@ -0,0 +1,1898 @@ +# 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.14.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_rc_files; end + def self.load_requires; end + def self.load_traps; end + def self.load_win32console; 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.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::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_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_in_value; end + def argument_in_value=(arg0); end + def call(*objects); end + def config; end + def count; end + def count=(arg0); 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 long; end + def short; 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::CLI + def self.add_option_processor(&block); end + def self.add_options(&block); 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::ExitAll < Pry::ClassCommand + def process; 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/rainbow.rbi b/sorbet/rbi/gems/rainbow.rbi new file mode 100644 index 0000000..64c3036 --- /dev/null +++ b/sorbet/rbi/gems/rainbow.rbi @@ -0,0 +1,122 @@ +# 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/rake.rbi b/sorbet/rbi/gems/rake.rbi new file mode 100644 index 0000000..2e1cc82 --- /dev/null +++ b/sorbet/rbi/gems/rake.rbi @@ -0,0 +1,649 @@ +# 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 +class Rake::TaskLib + include Rake::Cloneable + include Rake::DSL +end diff --git a/sorbet/rbi/gems/regexp_parser.rbi b/sorbet/rbi/gems/regexp_parser.rbi new file mode 100644 index 0000000..b284de3 --- /dev/null +++ b/sorbet/rbi/gems/regexp_parser.rbi @@ -0,0 +1,941 @@ +# 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.4.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 type?(test_type); 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 + 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 + 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(subexpression, params = nil, active_opts = nil); end + def self.at_levels(level, set_level, conditional_level); 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::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 +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::Expression::Root < Regexp::Expression::Subexpression + def self.build(options = nil); end + def self.build_token; 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 +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/rexml.rbi b/sorbet/rbi/gems/rexml.rbi new file mode 100644 index 0000000..d3021c4 --- /dev/null +++ b/sorbet/rbi/gems/rexml.rbi @@ -0,0 +1,599 @@ +# 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/rspec-core.rbi b/sorbet/rbi/gems/rspec-core.rbi new file mode 100644 index 0000000..0d3bdf2 --- /dev/null +++ b/sorbet/rbi/gems/rspec-core.rbi @@ -0,0 +1,1929 @@ +# 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.10.2 + +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.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 initialize(*arg0); end + def is_expected; 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 except(*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 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_msgpack(*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::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 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 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 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 method_missing(name, *args, &block); end + def noecho(*args, &block); end + def nonblock(*args, &block); end + def nonblock=(*args, &block); end + def nonblock?(*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_priority(*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 [](*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 eql?(*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 +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 +module RSpec::Core::MockingAdapters +end +module RSpec::Core::MockingAdapters::RSpec + def self.configuration; end + def self.framework_name; end + def setup_mocks_for_rspec; end + def teardown_mocks_for_rspec; end + def verify_mocks_for_rspec; end + include RSpec::Mocks::ExampleMethods + include RSpec::Mocks::ExampleMethods::ExpectHost +end diff --git a/sorbet/rbi/gems/rspec-expectations.rbi b/sorbet/rbi/gems/rspec-expectations.rbi new file mode 100644 index 0000000..824c045 --- /dev/null +++ b/sorbet/rbi/gems/rspec-expectations.rbi @@ -0,0 +1,1149 @@ +# 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.10.2 + +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 + 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 + 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::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 +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_16 +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 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 +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 +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 +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 supports_block_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_17 < 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_17 + 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 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_18 < 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_18 + 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 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 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 + 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 +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 +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 +end diff --git a/sorbet/rbi/gems/rspec-mocks.rbi b/sorbet/rbi/gems/rspec-mocks.rbi new file mode 100644 index 0000000..51a1e28 --- /dev/null +++ b/sorbet/rbi/gems/rspec-mocks.rbi @@ -0,0 +1,1087 @@ +# 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.10.3 + +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_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::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 +end +class Class < Module +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_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_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-support.rbi b/sorbet/rbi/gems/rspec-support.rbi new file mode 100644 index 0000000..3fe9e6e --- /dev/null +++ b/sorbet/rbi/gems/rspec-support.rbi @@ -0,0 +1,280 @@ +# 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.10.3 + +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.rbi b/sorbet/rbi/gems/rspec.rbi new file mode 100644 index 0000000..5e521c5 --- /dev/null +++ b/sorbet/rbi/gems/rspec.rbi @@ -0,0 +1,15 @@ +# 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.10.0 + +module RSpec +end +module RSpec::Version +end diff --git a/sorbet/rbi/gems/rubocop-ast.rbi b/sorbet/rbi/gems/rubocop-ast.rbi new file mode 100644 index 0000000..c3381a3 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-ast.rbi @@ -0,0 +1,1387 @@ +# 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.18.0 + +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 abbrev(*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_msgpack(*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 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-rspec.rbi b/sorbet/rbi/gems/rubocop-rspec.rbi new file mode 100644 index 0000000..a7b2555 --- /dev/null +++ b/sorbet/rbi/gems/rubocop-rspec.rbi @@ -0,0 +1,1024 @@ +# 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.5.0 + +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::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 +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::RSpec::Language +end +module RuboCop::RSpec::FactoryBot + def self.attribute_defining_methods; end + def self.reserved_methods; end +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 + 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 inside_spec?(node); end + def message(range); end + def on_block(node); end + def root_node?(node); end + def root_with_siblings?(node); end + def spec?(param0 = nil); end + extend RuboCop::Cop::AutoCorrector +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 contains_only_factory?(node); end + def factory_call(param0 = nil); end + def factory_list_call(param0 = nil); end + def n_times_block_without_arg?(param0 = nil); end + def on_block(node); end + def on_send(node); end + extend RuboCop::Cop::AutoCorrector + include RuboCop::Cop::ConfigurableEnforcedStyle +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_singeline_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 +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::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::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::BeforeAfterAll < RuboCop::Cop::RSpec::Base + def before_or_after_all(param0 = nil); end + def on_send(node); end +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 skip_blocks?; 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?(if_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 in_spec_block?(node); end + def on_block(node); end + extend RuboCop::Cop::AutoCorrector + include RuboCop::Cop::RSpec::EmptyLineSeparation +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 in_spec_block?(node); end + def offending?(node); end + def offending_node(node); end + def on_block(node); end + def parent(node); end + extend RuboCop::Cop::AutoCorrector +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_subjects(node); end + def find_subject_expectations(node, subject_names = nil, &block); 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 on_send(node); end + def string?(node); end + def style_violation?(variable); end + def symbol?(node); end + 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::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 +module RuboCop::Cop::Layout +end +class RuboCop::Cop::Layout::ExtraSpacing < RuboCop::Cop::Base + def self.autocorrect_incompatible_with; end +end +class RuboCop::AST::Node < Parser::AST::Node + include RuboCop::RSpec::Node +end diff --git a/sorbet/rbi/gems/rubocop.rbi b/sorbet/rbi/gems/rubocop.rbi new file mode 100644 index 0000000..129b0ec --- /dev/null +++ b/sorbet/rbi/gems/rubocop.rbi @@ -0,0 +1,8821 @@ +# 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.30.0 + +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 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::DefNode + def non_public?(node); end + def non_public_modifier?(param0 = nil); end + def preceding_non_public_modifier?(node); end + def stripped_source_upto(index); end + extend RuboCop::AST::NodePattern::Macros +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:, side: nil, newlines: nil, whitespace: nil, continuations: nil); end + def source_range(source_buffer, line_number, column, length = nil); end +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 base_column(left_brace, left_parenthesis); end + 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 incorrect_style_detected(styles, first, left_parenthesis); 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::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::DateAssignment < RuboCop::Cop::Base + def on_block(block_node); end + extend RuboCop::Cop::AutoCorrector + include RuboCop::Cop::GemspecHelp + include RuboCop::Cop::RangeHelp +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 gem_specification(param0 = nil); end + def on_block(block_node); end + def use_test_files?(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 next_line_empty?(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(left_parenthesis); end + def brace_alignment_style; end + def check(array_node, left_parenthesis); end + def check_right_bracket(right_bracket, left_bracket, left_parenthesis); end + def message(base_description); end + def msg(left_parenthesis); 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(left_parenthesis); 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, left_brace, left_parenthesis); end + def enforce_first_argument_with_fixed_indentation?; end + def message(base_description); end + def message_for_right_brace(left_parenthesis); 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::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 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::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::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::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_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 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 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 collect_detections(node); 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::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 opposite_keyword(node); end + def register_offense(node, scope_exiting_keyword, conditional_keyword); end + def too_long_for_single_line?(node, example); 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?(param0 = nil); end + def except_key(node); 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 auto_correct(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 if_node(node); end + def on_if(node); end + def remove_parentheses(source); end + extend RuboCop::Cop::AutoCorrector +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 + 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 offensive_for_mode?(receiver_node); 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 +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 +module RuboCop::Formatter::TextUtil + def pluralize(number, thing, options = nil); end + def self.pluralize(number, thing, options = nil); 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_auto_correct: 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 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_auto_correct?(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 github_escape(string); end + def github_severity(offense); end + def minimum_severity_to_fail; end + def report_offense(file, offense); 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 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_auto_correct?(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_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/ruby-progressbar.rbi b/sorbet/rbi/gems/ruby-progressbar.rbi new file mode 100644 index 0000000..81b2335 --- /dev/null +++ b/sorbet/rbi/gems/ruby-progressbar.rbi @@ -0,0 +1,304 @@ +# 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/simplecov-html.rbi b/sorbet/rbi/gems/simplecov-html.rbi new file mode 100644 index 0000000..a4ccda1 --- /dev/null +++ b/sorbet/rbi/gems/simplecov-html.rbi @@ -0,0 +1,31 @@ +# 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.10.2 + +module SimpleCov +end +module SimpleCov::Formatter +end +class SimpleCov::Formatter::HTMLFormatter + def asset_output_path; end + def assets_path(name); end + def coverage_css_class(covered_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 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.rbi b/sorbet/rbi/gems/simplecov.rbi new file mode 100644 index 0000000..d6deba5 --- /dev/null +++ b/sorbet/rbi/gems/simplecov.rbi @@ -0,0 +1,226 @@ +# 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.17.1 + +module SimpleCov + def self.add_not_loaded_files(result); end + def self.clear_result; end + def self.exit_exception; end + def self.exit_status_from_exception; end + def self.filtered(files); end + def self.final_result_process?; end + def self.grouped(files); end + def self.load_adapter(name); end + def self.load_profile(name); end + def self.pid; end + def self.pid=(arg0); end + def self.process_result(result, exit_status); end + def self.result; end + def self.result?; end + def self.result_exit_status(result, covered_percent); end + def self.run_exit_tasks!; end + def self.running; end + def self.running=(arg0); end + def self.set_exit_exception; end + def self.start(profile = nil, &block); end + def self.usable?; end + def self.wait_for_other_processes; end + def self.write_last_run(covered_percent); end + extend SimpleCov::Configuration +end +module SimpleCov::Formatter +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 command_name(name = nil); end + def configure(&block); end + def coverage_dir(dir = nil); end + def coverage_path; 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 nocov_token(nocov_token = nil); end + def parse_filter(filter_argument = nil, &filter_proc); end + def profiles; end + def project_name(new_name = nil); end + def refuse_coverage_drop; 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 +module SimpleCov::ExitCodes +end +class SimpleCov::Profiles < Hash + def define(name, &blk); end + def load(name); end +end +class SimpleCov::SourceFile + def build_lines; end + def coverage; end + def coverage_exceeding_source_warn; end + def covered_lines; end + def covered_percent; end + def covered_strength; end + def filename; end + def initialize(filename, coverage); end + def line(number); end + def lines; end + def lines_of_code; end + def lines_strength; end + def missed_lines; end + def never_lines; end + def no_lines?; end + def process_skipped_lines(lines); end + def project_filename; end + def relevant_lines; end + def round_float(float, places); end + def skipped_lines; end + def source; end + def source_lines; end + def src; 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::FileList < Array + def covered_lines; end + def covered_percent; end + def covered_percentages; end + def covered_strength; end + def least_covered_file; end + def lines_of_code; end + def missed_lines; end + def never_lines; end + def skipped_lines; end +end +class SimpleCov::Result + def command_name; end + def command_name=(arg0); end + def coverage; 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); end + def least_covered_file(*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_lines(*args, &block); end + extend Forwardable +end +class SimpleCov::Filter + def filter_argument; end + def initialize(filter_argument); end + def matches?(_); 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::RawCoverage + def merge_file_coverage(file1, file2); end + def merge_line_coverage(count1, count2); end + def merge_results(*results); end + def merge_resultsets(result1, result2); end + def self.merge_file_coverage(file1, file2); end + def self.merge_line_coverage(count1, count2); end + def self.merge_results(*results); end + def self.merge_resultsets(result1, result2); end +end +module SimpleCov::ResultMerger + def self.clear_resultset; end + def self.merge_results(*results); end + def self.merged_result; end + def self.results; end + def self.resultset; end + def self.resultset_path; end + def self.resultset_writelock; end + def self.store_result(result); end + def self.stored_data; end + def self.synchronize_resultset; 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 diff --git a/sorbet/rbi/gems/sord.rbi b/sorbet/rbi/gems/sord.rbi new file mode 100644 index 0000000..1fa5c1c --- /dev/null +++ b/sorbet/rbi/gems/sord.rbi @@ -0,0 +1,69 @@ +# 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/sord/all/sord.rbi +# +# sord-3.0.1 + +module Sord +end +module Sord::Logging + def self.add_hook(&blk); end + def self.done(msg, item = nil); end + def self.duck(msg, item = nil); end + def self.enabled_types; end + def self.enabled_types=(value); end + def self.error(msg, item = nil); end + def self.generic(kind, header, msg, item); end + def self.hooks; end + def self.infer(msg, item = nil); end + def self.info(msg, item = nil); end + def self.invoke_hooks(kind, msg, item); end + def self.omit(msg, item = nil); end + def self.silent=(value); end + def self.silent?; end + def self.valid_types?(value); end + def self.warn(msg, item = nil); end +end +module Sord::Resolver + def self.builtin_classes; end + def self.clear; end + def self.path_for(name); end + def self.paths_for(name); end + def self.prepare; end + def self.resolvable?(name, item); end +end +module Sord::TypeConverter + def self.handle_sord_error(name, log_warning, item, replace_errors_with_untyped); end + def self.split_type_parameters(params); end + def self.yard_to_parlour(yard, item = nil, replace_errors_with_untyped = nil, replace_unresolved_with_untyped = nil); end +end +class Sord::Generator + def add_attributes(item); end + def add_comments(item, typed_object); end + def add_constants(item); end + def add_methods(item); end + def add_mixins(item); end + def add_namespace(item); end + def count_method; end + def count_namespace; end + def generate; end + def initialize(options); end + def object_count; end + def populate; end + def run; end + def sort_params(pair1, pair2); end + def warnings; end +end +class Sord::ParlourPlugin < Parlour::Plugin + def generate(root); end + def initialize(options); end + def options; end + def parlour; end + def parlour=(arg0); end + def self.with_clean_env(&block); end +end diff --git a/sorbet/rbi/gems/thor.rbi b/sorbet/rbi/gems/thor.rbi new file mode 100644 index 0000000..56744f5 --- /dev/null +++ b/sorbet/rbi/gems/thor.rbi @@ -0,0 +1,541 @@ +# 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_19 < 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_19 + 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/unicode-display_width.rbi b/sorbet/rbi/gems/unicode-display_width.rbi new file mode 100644 index 0000000..e1e4acc --- /dev/null +++ b/sorbet/rbi/gems/unicode-display_width.rbi @@ -0,0 +1,20 @@ +# 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.1.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/vcr.rbi b/sorbet/rbi/gems/vcr.rbi new file mode 100644 index 0000000..8d860e5 --- /dev/null +++ b/sorbet/rbi/gems/vcr.rbi @@ -0,0 +1,575 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi gems + +# typed: ignore +# +# 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/vcr/all/vcr.rbi +# +# vcr-4.0.0 + +module VCR + def cassette_persisters; end + def cassette_serializers; end + def cassettes(context = nil); end + def config; end + def configuration; end + def configure; end + def context_cassettes; end + def context_value(name); end + def cucumber_tags(&block); end + def current_cassette; end + def current_context; end + def dup_context(context); end + def eject_cassette(options = nil); end + def fibers_available?; end + def get_context(thread_key, fiber_key = nil); end + def http_interactions; end + def ignore_cassettes?; end + def initialize_fibers; end + def initialize_ivars; end + def insert_cassette(name, options = nil); end + def library_hooks; end + def link_context(from_thread, to_key); end + def real_http_connections_allowed?; end + def record_http_interaction(interaction); end + def request_ignorer; end + def request_matchers; end + def self.const_missing(const); end + def set_context_value(name, value); end + def turn_off!(options = nil); end + def turn_on!; end + def turned_off(options = nil); end + def turned_on?; end + def unlink_context(key); end + def use_cassette(name, options = nil, &block); end + def use_cassettes(cassettes, &block); end + def version; end + extend VCR + extend VCR + include VCR::Errors + include VCR::VariableArgsBlockCaller +end +class VCR::Logger + def initialize(stream); end + def log(message, log_prefix, indentation_level = nil); end + def request_summary(request, request_matchers); end + def response_summary(response); end +end +module VCR::Logger::Null + def log(*arg0); end + def request_summary(*arg0); end + def response_summary(*arg0); end + def self.log(*arg0); end + def self.request_summary(*arg0); end + def self.response_summary(*arg0); end +end +module VCR::Logger::Mixin + def log(message, indentation_level = nil); end + def request_summary(*args); end + def response_summary(*args); end +end +module VCR::VariableArgsBlockCaller + def call_block(block, *args); end +end +class VCR::Cassette + def assert_valid_options!; end + def assign_tags; end + def clean_outdated_http_interactions; end + def deserialized_hash; end + def eject(options = nil); end + def erb; end + def extract_options; end + def file; end + def http_interactions; end + def initialize(name, options = nil); end + def interactions_to_record; end + def invoke_hook(type, interactions); end + def linked?; end + def log_prefix; end + def match_requests_on; end + def merged_interactions; end + def name; end + def new_recorded_interactions; end + def originally_recorded_at; end + def previously_recorded_interactions; end + def raise_error_unless_valid_record_mode; end + def raw_cassette_bytes; end + def re_record_interval; end + def record_http_interaction(interaction); end + def record_mode; end + def recording?; end + def request_summary(request); end + def self.const_missing(const); end + def serializable_hash; end + def should_assert_no_unused_interactions?; end + def should_re_record?; end + def should_remove_matching_existing_interactions?; end + def should_stub_requests?; end + def storage_key; end + def tags; end + def up_to_date_interactions(interactions); end + def write_recorded_interactions_to_disk; end + include VCR::Logger::Mixin +end +class VCR::Cassette::HTTPInteractionList + def allow_playback_repeats; end + def assert_no_unused_interactions!; end + def has_interaction_matching?(request); end + def has_unused_interactions?; end + def has_used_interaction_matching?(request); end + def initialize(interactions, request_matchers, allow_playback_repeats = nil, parent_list = nil, log_prefix = nil); end + def interaction_matches_request?(request, interaction); end + def interactions; end + def log_prefix; end + def matching_interaction_index_for(request); end + def matching_used_interaction_for(request); end + def parent_list; end + def remaining_unused_interaction_count; end + def request_matchers; end + def request_summary(request); end + def response_for(request); end + include VCR::Logger::Mixin +end +module VCR::Cassette::HTTPInteractionList::NullList + def has_interaction_matching?(*a); end + def has_used_interaction_matching?(*a); end + def remaining_unused_interaction_count(*a); end + def response_for(*a); end + extend VCR::Cassette::HTTPInteractionList::NullList +end +class VCR::Cassette::ERBRenderer + def binding_for_variables; end + def erb_variables; end + def handle_name_error(e); end + def initialize(raw_template, erb, cassette_name = nil); end + def render; end + def template; end + def use_erb?; end + def variables_object; end +end +class VCR::Cassette::Serializers + def [](name); end + def []=(name, value); end + def initialize; end +end +module VCR::Cassette::EncodingErrorHandling + def handle_encoding_errors; end +end +class VCR::Cassette::Persisters + def [](name); end + def []=(name, value); end + def initialize; end +end +module VCR::Errors +end +class VCR::Errors::Error < StandardError +end +class VCR::Errors::CassetteInUseError < VCR::Errors::Error +end +class VCR::Errors::TurnedOffError < VCR::Errors::Error +end +class VCR::Errors::MissingERBVariableError < VCR::Errors::Error +end +class VCR::Errors::LibraryVersionTooLowError < VCR::Errors::Error +end +class VCR::Errors::UnregisteredMatcherError < VCR::Errors::Error +end +class VCR::Errors::InvalidCassetteFormatError < VCR::Errors::Error +end +class VCR::Errors::AroundHTTPRequestHookError < VCR::Errors::Error +end +class VCR::Errors::NotSupportedError < VCR::Errors::Error +end +class VCR::Errors::UnknownContentEncodingError < VCR::Errors::Error +end +class VCR::Errors::UnusedHTTPInteractionError < VCR::Errors::Error +end +class VCR::Errors::EjectLinkedCassetteError < VCR::Errors::Error +end +class VCR::Errors::UnhandledHTTPRequestError < VCR::Errors::Error + def cassettes_description; end + def cassettes_list; end + def construct_message; end + def current_cassettes; end + def current_matchers; end + def format_bullet_point(lines, index); end + def format_foot_note(url, index); end + def formatted_headers; end + def formatted_suggestions; end + def has_used_interaction_matching?; end + def initialize(request); end + def match_request_on_body?; end + def match_request_on_headers?; end + def match_requests_on_suggestion; end + def no_cassette_suggestions; end + def record_mode_suggestion; end + def relish_version_slug; end + def request; end + def request_description; end + def suggestion_for(key); end + def suggestions; end +end +class VCR::LinkedCassette < SimpleDelegator + def eject(*args); end + def linked?; end + def self.list(cassettes, linked_cassettes); end +end +class VCR::LinkedCassette::CassetteList + def each; end + def initialize(cassettes, linked_cassettes); end + def last; end + def size; end + def wrap(cassette); end + include Enumerable +end +module VCR::Hooks + def clear_hooks; end + def has_hooks_for?(hook_type); end + def hooks; end + def invoke_hook(hook_type, *args); end + def self.included(klass); end + include VCR::VariableArgsBlockCaller +end +class VCR::Hooks::FilteredHook < Struct + def conditionally_invoke(*args); end + def filters; end + def filters=(_); end + def hook; end + def hook=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + include VCR::VariableArgsBlockCaller +end +module VCR::Hooks::ClassMethods + def define_hook(hook_type, prepend = nil); end +end +class VCR::Configuration + def after_http_request(*filters); end + def allow_http_connections_when_no_cassette=(arg0); end + def allow_http_connections_when_no_cassette?; end + def around_http_request(*filters, &block); end + def before_playback(tag = nil, &block); end + def before_record(tag = nil, &block); end + def cassette_library_dir; end + def cassette_library_dir=(dir); end + def cassette_persisters; end + def cassette_serializers; end + def configure_rspec_metadata!; end + def create_fiber_for(fiber_errors, hook_declaration, proc); end + def debug_logger; end + def debug_logger=(value); end + def default_cassette_options; end + def default_cassette_options=(overrides); end + def define_cassette_placeholder(placeholder, tag = nil, &block); end + def filter_sensitive_data(placeholder, tag = nil, &block); end + def hook_into(*hooks); end + def ignore_host(*hosts); end + def ignore_hosts(*hosts); end + def ignore_localhost=(value); end + def ignore_request(&block); end + def initialize; end + def load_library_hook(hook); end + def log_prefix; end + def logger; end + def preserve_exact_body_bytes_for?(http_message); end + def query_parser; end + def query_parser=(arg0); end + def register_built_in_hooks; end + def register_request_matcher(name, &block); end + def request_filter_from(object); end + def resume_fiber(fiber, fiber_errors, response, hook_declaration); end + def start_new_fiber_for(request, fibers, fiber_errors, hook_declaration, proc); end + def stub_with(*adapters); end + def tag_filter_from(tag); end + def uri_parser; end + def uri_parser=(arg0); end + extend VCR::Hooks::ClassMethods + include VCR::Configuration::DefinedHooks + include VCR::Hooks + include VCR::Logger::Mixin + include VCR::VariableArgsBlockCaller +end +module VCR::Configuration::DefinedHooks + def after_http_request(*filters, &hook); end + def after_library_hooks_loaded(*filters, &hook); end + def before_http_request(*filters, &hook); end + def before_playback(*filters, &hook); end + def before_record(*filters, &hook); end + def preserve_exact_body_bytes(*filters, &hook); end +end +module VCR::Deprecations +end +module VCR::Deprecations::Middleware +end +module VCR::Deprecations::Middleware::Faraday + def initialize(*args); end +end +class VCR::LibraryHooks + def disabled?(hook); end + def exclusive_hook; end + def exclusive_hook=(arg0); end + def exclusively_enabled(hook); end +end +class VCR::RequestIgnorer + def ignore?(request); end + def ignore_hosts(*hosts); end + def ignore_localhost=(value); end + def ignored_hosts; end + def initialize; end + extend VCR::Hooks::ClassMethods + include VCR::Hooks + include VCR::RequestIgnorer::DefinedHooks +end +module VCR::RequestIgnorer::DefinedHooks + def ignore_request(*filters, &hook); end +end +class VCR::RequestMatcherRegistry + def [](matcher); end + def initialize; end + def raise_unregistered_matcher_error(name); end + def register(name, &block); end + def register_built_ins; end + def try_to_register_body_as_json; end + def uri_without_param(*ignores); end + def uri_without_param_matchers; end + def uri_without_params(*ignores); end +end +class Anonymous_Struct_20 < Struct + def callable; end + def callable=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end +end +class VCR::RequestMatcherRegistry::Matcher < Anonymous_Struct_20 + def matches?(request_1, request_2); end +end +class Anonymous_Struct_21 < Struct + def params_to_ignore; end + def params_to_ignore=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end +end +class VCR::RequestMatcherRegistry::URIWithoutParamsMatcher < Anonymous_Struct_21 + def call(request_1, request_2); end + def partial_uri_from(request); end + def to_proc; end +end +module VCR::Normalizers +end +module VCR::Normalizers::Body + def base_body_hash(body); end + def initialize(*args); end + def self.included(klass); end + def serializable_body; end +end +module VCR::Normalizers::Body::ClassMethods + def body_from(hash_or_string); end + def force_encode_string(string, encoding); end + def try_encode_string(string, encoding); end +end +module VCR::Normalizers::Header + def convert_to_raw_strings(array); end + def delete_header(key); end + def edit_header(key, value = nil); end + def get_header(key); end + def header_key(key); end + def initialize(*args); end + def normalize_headers; end +end +module VCR::OrderedHashSerializer + def each; end + def self.apply_to(*args); end +end +class Anonymous_Struct_22 < Struct + def body; end + def body=(_); end + def headers; end + def headers=(_); end + def method; end + def method=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def uri; end + def uri=(_); end +end +class VCR::Request < Anonymous_Struct_22 + def initialize(*args); end + def method(*args); end + def parsed_uri; end + def self.from_hash(hash); end + def to_hash; end + def without_standard_port(uri); end + extend VCR::Normalizers::Body::ClassMethods + include VCR::Normalizers::Body + include VCR::Normalizers::Header +end +class VCR::Request::Typed < Anonymous_Delegator_23 + def externally_stubbed?; end + def ignored?; end + def initialize(request, type); end + def real?; end + def recordable?; end + def stubbed?; end + def stubbed_by_vcr?; end + def type; end + def unhandled?; end +end +class VCR::Request::FiberAware < Anonymous_Delegator_24 + def proceed; end + def to_proc; end +end +class Anonymous_Struct_25 < Struct + def adapter_metadata; end + def adapter_metadata=(_); end + def body; end + def body=(_); end + def headers; end + def headers=(_); end + def http_version; end + def http_version=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end + def status; end + def status=(_); end +end +class VCR::Response < Anonymous_Struct_25 + def compressed?; end + def content_encoding; end + def decompress; end + def initialize(*args); end + def self.decompress(body, type); end + def self.from_hash(hash); end + def to_hash; end + def update_content_length_header; end + extend VCR::Normalizers::Body::ClassMethods + include VCR::Normalizers::Body + include VCR::Normalizers::Header +end +class Anonymous_Struct_26 < Struct + def code; end + def code=(_); end + 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 VCR::ResponseStatus < Anonymous_Struct_26 + def self.from_hash(hash); end + def to_hash; end +end +class Anonymous_Struct_27 < Struct + def recorded_at; end + def recorded_at=(_); end + def request; end + def request=(_); end + def response; end + def response=(_); end + def self.[](*arg0); end + def self.inspect; end + def self.members; end + def self.new(*arg0); end +end +class VCR::HTTPInteraction < Anonymous_Struct_27 + def hook_aware; end + def initialize(*args); end + def self.from_hash(hash); end + def to_hash; end +end +class VCR::HTTPInteraction::HookAware < Anonymous_Delegator_28 + def filter!(text, replacement_text); end + def filter_hash!(hash, text, replacement_text); end + def filter_object!(object, text, replacement_text); end + def ignore!; end + def ignored?; end + def initialize(http_interaction); end +end +module VCR::RSpec +end +module VCR::Middleware +end +module VCR::Cassette::Persisters::FileSystem + def [](file_name); end + def []=(file_name, content); end + def absolute_path_for(path); end + def absolute_path_to_file(file_name); end + def sanitized_file_name_from(file_name); end + def storage_location; end + def storage_location=(dir); end + extend VCR::Cassette::Persisters::FileSystem +end +class VCR::VersionChecker + def check_version!; end + def compare_version; end + def initialize(library_name, library_version, min_version); end + def parse_version(version); end + def raise_too_low_error; end + def too_low?; end + def version_requirement; end +end +class VCR::RequestHandler + def disabled?; end + def externally_stubbed?; end + def handle; end + def has_response_stub?(consume_stub); end + def invoke_after_request_hook(vcr_response); end + def invoke_before_request_hook; end + def library_name; end + def log_prefix; end + def on_externally_stubbed_request; end + def on_ignored_request; end + def on_recordable_request; end + def on_stubbed_by_vcr_request; end + def on_unhandled_request; end + def request_summary; end + def request_type(consume_stub = nil); end + def set_typed_request_for_after_hook(request_type); end + def should_ignore?; end + def stubbed_response; end + include VCR::Logger::Mixin +end +class VCR::Middleware::Faraday + def call(env); end + def initialize(app); end + include VCR::Deprecations::Middleware::Faraday +end +class VCR::Middleware::Faraday::RequestHandler < VCR::RequestHandler + def app; end + def delay_finishing?; end + def env; end + def handle; end + def initialize(app, env); end + def invoke_after_request_hook(response); end + def on_ignored_request; end + def on_recordable_request; end + def on_stubbed_by_vcr_request; end + def raw_body_from(body); end + def response_for(response); end + def vcr_request; end +end +module VCR::LibraryHooks::Faraday +end +module VCR::LibraryHooks::Faraday::BuilderClassExtension + def new(*args); end +end +class Faraday::RackBuilder + extend VCR::LibraryHooks::Faraday::BuilderClassExtension +end +module VCR::LibraryHooks::Faraday::BuilderInstanceExtension + def insert_vcr_middleware; end + def lock!(*args); end + def warn_about_after_adapter_middleware(adapter_index); end +end diff --git a/sorbet/rbi/gems/yard.rbi b/sorbet/rbi/gems/yard.rbi new file mode 100644 index 0000000..efaba42 --- /dev/null +++ b/sorbet/rbi/gems/yard.rbi @@ -0,0 +1,1168 @@ +# 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.27 + +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.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 Array + def place(*values); end +end +class File < IO + def self.absolute_path(*arg0); end + def self.absolute_path?(arg0); end + def self.mkfifo(*arg0); end + def self.realdirpath(*arg0); 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 Module + def class_name; end +end +class String + def shell_split; 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 +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 +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 +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 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_fndptn(*args); 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::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 diff --git a/sorbet/rbi/hidden-definitions/errors.txt b/sorbet/rbi/hidden-definitions/errors.txt new file mode 100644 index 0000000..f3a6113 --- /dev/null +++ b/sorbet/rbi/hidden-definitions/errors.txt @@ -0,0 +1,8667 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi hidden-definitions + +# typed: autogenerated + +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name > +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name connect_internal +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant Appraisal::Git::PARTS +# wrong constant name initialize +# wrong constant name +# uninitialized constant Appraisal::Group::PARTS +# wrong constant name initialize +# wrong constant name +# uninitialized constant Appraisal::Path::PARTS +# wrong constant name initialize +# wrong constant name +# uninitialized constant Appraisal::Platform::PARTS +# wrong constant name initialize +# wrong constant name +# uninitialized constant Appraisal::Source::PARTS +# wrong constant name initialize +# wrong constant name +# 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 +# uninitialized constant Benchmark +# uninitialized constant Benchmark +# wrong constant name clone +# wrong constant name n_significant_digits +# wrong constant name precision +# wrong constant name interpret_loosely +# wrong constant name clone +# wrong constant name irb +# wrong constant name +# wrong constant name status_code +# wrong constant name +# wrong constant name jruby_30? +# wrong constant name jruby_31? +# wrong constant name jruby_3? +# wrong constant name maglev_30? +# wrong constant name maglev_31? +# wrong constant name maglev_3? +# wrong constant name mingw_30? +# wrong constant name mingw_31? +# wrong constant name mingw_3? +# wrong constant name mri_30? +# wrong constant name mri_31? +# wrong constant name mri_3? +# wrong constant name mswin64_30? +# wrong constant name mswin64_31? +# wrong constant name mswin64_3? +# wrong constant name mswin_30? +# wrong constant name mswin_31? +# wrong constant name mswin_3? +# wrong constant name on_30? +# wrong constant name on_31? +# wrong constant name on_3? +# wrong constant name rbx_30? +# wrong constant name rbx_31? +# wrong constant name rbx_3? +# wrong constant name ruby_30? +# wrong constant name ruby_31? +# wrong constant name ruby_3? +# wrong constant name truffleruby_30? +# wrong constant name truffleruby_31? +# wrong constant name truffleruby_3? +# wrong constant name x64_mingw_30? +# wrong constant name x64_mingw_31? +# wrong constant name x64_mingw_3? +# uninitialized constant Bundler::Definition::GENERICS +# uninitialized constant Bundler::Definition::GENERIC_CACHE +# wrong constant name dependencies_for +# wrong constant name locked_dependencies +# wrong constant name most_specific_locked_platform +# wrong constant name requested_dependencies +# wrong constant name resolve_only_locally! +# wrong constant name no_lock +# wrong constant name no_lock= +# wrong constant name clone +# wrong constant name get_proxy +# uninitialized constant Bundler::Dependency::TYPES +# wrong constant name branch +# wrong constant name expanded_platforms +# wrong constant name git +# wrong constant name github +# wrong constant name ref +# wrong constant name +# wrong constant name sha1 +# wrong constant name check_primary_source_safety +# wrong constant name +# wrong constant name environment +# wrong constant name report +# wrong constant name write +# wrong constant name replace_with_backup +# wrong constant name env_to_hash +# wrong constant name from_env +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# 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 +# wrong constant name initialize +# wrong constant name +# wrong constant name available? +# 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 +# wrong constant name [] +# wrong constant name members +# wrong constant name +# 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 +# wrong constant name connection +# wrong constant name fetch +# wrong constant name initialize +# wrong constant name redirect_limit +# wrong constant name request +# wrong constant name +# wrong constant name specs +# wrong constant name +# wrong constant name initialize +# wrong constant name +# 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_checksum +# wrong constant name build_gem +# wrong constant name built_gem_path +# wrong constant name clean? +# wrong constant name committed? +# wrong constant name current_branch +# wrong constant name default_remote +# 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 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_prefix= +# wrong constant name tag_version +# wrong constant name version +# wrong constant name version_tag +# wrong constant name +# wrong constant name gemspec +# wrong constant name install_tasks +# wrong constant name instance +# wrong constant name instance= +# wrong constant name tag_prefix= +# wrong constant name specificity_score +# wrong constant name local_platform +# wrong constant name same_deps +# wrong constant name same_specificity +# 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 +# wrong constant name +# 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 +# wrong constant name +# wrong constant name initialize +# wrong constant name inject +# wrong constant name remove +# wrong constant name +# wrong constant name inject +# wrong constant name remove +# wrong constant name definition +# uninitialized constant Bundler::LazySpecification::GENERICS +# uninitialized constant Bundler::LazySpecification::GENERIC_CACHE +# wrong constant name eql? +# wrong constant name platform_string +# uninitialized constant Bundler::LazySpecification::Identifier +# uninitialized constant Bundler::LazySpecification::Identifier +# wrong constant name bundled_with +# uninitialized constant Bundler::Molinillo::Compatibility +# Did you mean? Comparable +# uninitialized constant Bundler::Molinillo::Compatibility +# Did you mean? Comparable +# wrong constant name dependencies_equal? +# wrong constant name parent_folder +# wrong constant name permission_type +# wrong constant name == +# wrong constant name add_dependency_names +# wrong constant name app_cache_dirname +# wrong constant name app_cache_path +# 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 identifier +# wrong constant name include? +# wrong constant name initialize +# wrong constant name install +# wrong constant name install_path +# wrong constant name installed? +# wrong constant name local! +# 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 spec_names +# 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 +# wrong constant name +# wrong constant name +# wrong constant name installed_plugins +# wrong constant name plugin_commands +# wrong constant name unregister_plugin +# wrong constant name initialize +# wrong constant name +# wrong constant name initialize +# wrong constant name +# wrong constant name +# wrong constant name +# 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 +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name list +# wrong constant name save_plugin +# wrong constant name uninstall +# wrong constant name +# wrong constant name lock +# uninitialized constant Bundler::RemoteSpecification::GENERICS +# uninitialized constant Bundler::RemoteSpecification::GENERIC_CACHE +# wrong constant name required_rubygems_version +# uninitialized constant Bundler::Resolver::GENERICS +# uninitialized constant Bundler::Resolver::GENERIC_CACHE +# wrong constant name results_for +# wrong constant name source_for +# wrong constant name activated_platforms +# wrong constant name activated_platforms= +# wrong constant name sorted_activated_platforms +# wrong constant name create_for +# 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 +# wrong constant name attempts +# wrong constant name default_attempts +# wrong constant name default_retries +# wrong constant name add_default_gems_to +# 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_bundler +# wrong constant name find_name +# wrong constant name gem_remote_fetcher +# wrong constant name load_env_plugins +# wrong constant name plain_specs +# wrong constant name plain_specs= +# wrong constant name stub_rubygems +# wrong constant name supports_bundler_trampolining? +# 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 install_locked_bundler_and_restart_with_it_if_needed +# wrong constant name restart_with_locked_bundler_if_needed +# wrong constant name update_bundler_and_restart_with_it_if_needed +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name processor_count +# 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 +# wrong constant name each +# wrong constant name for +# wrong constant name initialize +# wrong constant name parse +# wrong constant name +# wrong constant name +# 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 +# wrong constant name +# wrong constant name validate! +# wrong constant name key_for +# wrong constant name +# wrong constant name add_dependency_names +# wrong constant name cached! +# wrong constant name identifier +# wrong constant name local! +# wrong constant name local_only! +# wrong constant name remote! +# wrong constant name spec_names +# uninitialized constant Bundler::Source::Git::DEFAULT_GLOB +# wrong constant name glob +# wrong constant name local? +# wrong constant name default_cache_path_for +# wrong constant name dependency_api_available? +# wrong constant name multiple_remotes? +# wrong constant name no_remotes? +# wrong constant name remote_names +# wrong constant name identifier +# wrong constant name initialize +# wrong constant name source_map +# wrong constant name sources +# wrong constant name specs +# wrong constant name +# wrong constant name add_global_rubygems_remote +# wrong constant name aggregate_global_source? +# wrong constant name expired_sources? +# wrong constant name global_path_source +# wrong constant name implicit_global_source? +# wrong constant name local_only! +# wrong constant name lock_other_sources +# wrong constant name lock_rubygems_sources +# wrong constant name merged_gem_lockfile_sections! +# wrong constant name merged_gem_lockfile_sections? +# wrong constant name non_default_explicit_sources +# wrong constant name non_global_rubygems_sources +# wrong constant name all_requirements +# wrong constant name dependencies +# wrong constant name direct_requirements +# wrong constant name initialize +# wrong constant name locked_requirements +# wrong constant name locked_specs +# wrong constant name pinned_spec_names +# wrong constant name sources +# wrong constant name +# wrong constant name missing_specs +# uninitialized constant Bundler::StubSpecification::GENERICS +# uninitialized constant Bundler::StubSpecification::GENERIC_CACHE +# wrong constant name extensions +# wrong constant name gem_build_complete_path +# wrong constant name manually_installed? +# wrong constant name +# wrong constant name each_strongly_connected_component +# wrong constant name each_strongly_connected_component_from +# wrong constant name strongly_connected_components +# wrong constant name tsort +# wrong constant name tsort_each +# wrong constant name tsort_each_child +# wrong constant name tsort_each_node +# wrong constant name +# wrong constant name +# wrong constant name each_strongly_connected_component +# wrong constant name each_strongly_connected_component_from +# wrong constant name strongly_connected_components +# wrong constant name tsort +# wrong constant name tsort_each +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant Bundler::Thor::SHELL_DELEGATED_METHODS +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name help +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# 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 +# 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 +# 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 +# wrong constant name +# 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 +# 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 +# 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 +# wrong constant name +# wrong constant name included +# wrong constant name +# 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 +# wrong constant name initialize +# wrong constant name parse +# wrong constant name remaining +# wrong constant name +# wrong constant name parse +# wrong constant name split +# wrong constant name +# 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 +# wrong constant name +# 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 +# wrong constant name +# 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 except +# 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 +# wrong constant name +# uninitialized constant Bundler::Thor::DynamicCommand::FILE_REGEXP +# wrong constant name initialize +# wrong constant name +# wrong constant name +# 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 +# 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 +# wrong constant name +# 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 +# wrong constant name +# wrong constant name included +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name options +# wrong constant name prompt +# wrong constant name readline +# wrong constant name +# wrong constant name available? +# wrong constant name +# wrong constant name initialize +# wrong constant name matches +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name best_available +# wrong constant name readline +# wrong constant name +# wrong constant name enter +# wrong constant name entered? +# wrong constant name +# wrong constant name initialize +# wrong constant name +# 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 +# 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 unshift +# wrong constant name +# 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 +# wrong constant name included +# wrong constant name rake_classes +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# 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_error +# 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_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 +# uninitialized constant Bundler::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 +# 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 +# wrong constant name +# wrong constant name +# 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 +# wrong constant name +# wrong constant name +# 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 +# wrong constant name +# wrong constant name +# 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 +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# 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::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 +# 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::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 +# 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::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 +# 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::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 +# 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::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 +# wrong constant name +# wrong constant name +# 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::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 +# 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::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 +# 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::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 +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name join +# wrong constant name parse +# wrong constant name regexp +# wrong constant name split +# wrong constant name +# wrong constant name +# wrong constant name make_components_hash +# wrong constant name +# 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 for +# 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 +# wrong constant name +# uninitialized constant Bundler::VersionRanges::NEq::Elem +# wrong constant name version +# wrong constant name version= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name <=> +# uninitialized constant Bundler::VersionRanges::ReqR::Elem +# wrong constant name +# 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 +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name empty? +# wrong constant name for +# wrong constant name for_many +# wrong constant name configure_gem_home_and_path +# wrong constant name most_specific_locked_platform? +# wrong constant name original_exec +# wrong constant name original_system +# wrong constant name preferred_gemfile_name +# wrong constant name reset_settings_and_root! +# wrong constant name self_manager +# wrong constant name unbundled_env +# wrong constant name unbundled_exec +# wrong constant name unbundled_system +# wrong constant name +# uninitialized constant CGI::RFC822_DAYS +# uninitialized constant CGI::RFC822_MONTHS +# uninitialized constant CGI::TABLE_FOR_ESCAPE_HTML__ +# 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 +# uninitialized constant CMath +# uninitialized constant CMath +# uninitialized constant CSV +# uninitialized constant CSV +# wrong constant name json_creatable? +# uninitialized constant CodeRay::Encoders::Terminal::DEFAULT_OPTIONS +# uninitialized constant CodeRay::Scanners::Java::DEFAULT_OPTIONS +# uninitialized constant CodeRay::Scanners::Java::Id +# uninitialized constant CodeRay::Scanners::Java::KINDS_NOT_LOC +# uninitialized constant CodeRay::Scanners::Java::SCANNER_STATE_INFO +# uninitialized constant CodeRay::Scanners::Java::SCAN_ERROR_MESSAGE +# uninitialized constant CodeRay::Scanners::Java::Version +# Did you mean? CodeRay::VERSION +# uninitialized constant CodeRay::Scanners::Scanner::Id +# uninitialized constant CodeRay::Scanners::Scanner::Version +# Did you mean? CodeRay::VERSION +# wrong constant name initialize +# wrong constant name render +# wrong constant name render_command +# wrong constant name +# wrong constant name template +# wrong constant name +# wrong constant name +# uninitialized constant Continuation +# uninitialized constant Continuation +# 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 +# wrong constant name +# wrong constant name initialize +# wrong constant name initialize +# wrong constant name perform +# wrong constant name +# wrong constant name block_yield +# wrong constant name perform_with_block +# wrong constant name +# 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 +# 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 +# wrong constant name mutex +# uninitialized constant Data +# Did you mean? Date +# uninitialized constant Data +# Did you mean? Date +# 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 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 +# 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 message_for +# wrong constant name +# wrong constant name corrections +# wrong constant name initialize +# wrong constant name path +# wrong constant name +# wrong constant name requireables +# wrong constant name augment +# wrong constant name correct +# wrong constant name dictionary +# wrong constant name dictionary_without_leaves +# wrong constant name dimensions +# wrong constant name find_leaves +# wrong constant name initialize +# wrong constant name plausible_dimensions +# wrong constant name possible_paths +# wrong constant name separator +# wrong constant name tree_depth +# wrong constant name +# 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? +# uninitialized constant Dry::Configurable::Setting::Nested::CLONEABLE_VALUE_TYPES +# Did you mean? Dry::Configurable::Setting::CLONEABLE_VALUE_TYPES +# uninitialized constant Dry::Configurable::Setting::Nested::DEFAULT_CONSTRUCTOR +# Did you mean? Dry::Configurable::Setting::DEFAULT_CONSTRUCTOR +# uninitialized constant Dry::Configurable::Setting::Nested::OPTIONS +# Did you mean? Dry::Configurable::Setting::OPTIONS +# 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 sum +# wrong constant name + +# wrong constant name +# wrong constant name +# wrong constant name +# 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 +# uninitialized constant Enumerator::Chain::Elem +# wrong constant name +# wrong constant name each +# wrong constant name initialize +# wrong constant name eager +# wrong constant name each +# wrong constant name +# wrong constant name to_proc +# wrong constant name produce +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# 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 +# 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 +# uninitialized constant Exception2MessageMapper +# uninitialized constant Exception2MessageMapper +# wrong constant name +# uninitialized constant Faraday::Adapter::NetHttp::CONTENT_LENGTH +# Did you mean? Faraday::Adapter::CONTENT_LENGTH +# uninitialized constant Faraday::Adapter::NetHttp::TIMEOUT_KEYS +# Did you mean? Faraday::Adapter::TIMEOUT_KEYS +# uninitialized constant Fcntl +# uninitialized constant Fcntl +# wrong constant name backtrace +# wrong constant name backtrace_locations +# wrong constant name blocking? +# wrong constant name initialize +# wrong constant name transfer +# wrong constant name blocking? +# wrong constant name current +# wrong constant name schedule +# wrong constant name scheduler +# wrong constant name set_scheduler +# uninitialized constant Fiddle +# Did you mean? File +# uninitialized constant Fiddle +# Did you mean? File +# uninitialized constant File::PRIORITY +# uninitialized constant File::READABLE +# uninitialized constant File::WRITABLE +# 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 _compile_method +# wrong constant name _delegator_method +# wrong constant name _valid_method? +# wrong constant name debug +# wrong constant name debug= +# wrong constant name receiver +# wrong constant name garbage_collect +# wrong constant name latest_compact_info +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant Gem::AvailableSet +# uninitialized constant Gem::AvailableSet +# wrong constant name plugins +# wrong constant name ipv4_fallback_enabled +# wrong constant name ipv4_fallback_enabled= +# wrong constant name <=> +# wrong constant name filters_bundler? +# uninitialized constant Gem::DependencyInstaller +# Did you mean? Gem::DependencyList +# uninitialized constant Gem::DependencyInstaller +# Did you mean? Gem::DependencyList +# wrong constant name deprecate +# wrong constant name next_rubygems_major_version +# wrong constant name rubygems_deprecate +# wrong constant name rubygems_deprecate_command +# wrong constant name +# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MONITOR +# uninitialized constant Gem::Ext::ExtConfBuilder::CHDIR_MUTEX +# wrong constant name +# wrong constant name build +# wrong constant name get_relative_path +# wrong constant name +# wrong constant name ensure_writable_dir +# wrong constant name gemdeps_load +# wrong constant name generate_plugins +# wrong constant name copy_to +# wrong constant name data_mode +# wrong constant name data_mode= +# wrong constant name dir_mode +# wrong constant name dir_mode= +# wrong constant name extract_files +# wrong constant name initialize +# wrong constant name prog_mode +# wrong constant name prog_mode= +# wrong constant name spec +# wrong constant name spec= +# wrong constant name +# wrong constant name inherited +# wrong constant name regenerate_plugins_for +# wrong constant name remove_plugins_for +# wrong constant name +# wrong constant name home +# wrong constant name initialize +# wrong constant name path +# wrong constant name spec_cache_dir +# wrong constant name match_gem? +# wrong constant name match_spec? +# wrong constant name _sorted_requirements +# wrong constant name parse +# wrong constant name +# wrong constant name new +# wrong constant name eql? +# wrong constant name +# wrong constant name == +# wrong constant name force +# wrong constant name force= +# wrong constant name +# wrong constant name unused_unwind_options +# wrong constant name dependencies_equal? +# wrong constant name +# 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 +# uninitialized constant Gem::Resolver::Molinillo::DependencyGraph::Log::Elem +# wrong constant name _path_to? +# wrong constant name _recursive_predecessors +# wrong constant name _recursive_successors +# wrong constant name unused_unwind_options +# wrong constant name unused_unwind_options= +# wrong constant name possibility_set +# wrong constant name possibility_set= +# wrong constant name underlying_error +# wrong constant name underlying_error= +# uninitialized constant Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet::Elem +# wrong constant name dependencies +# wrong constant name dependencies= +# wrong constant name latest_version +# wrong constant name possibilities +# wrong constant name possibilities= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name <=> +# uninitialized constant Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails::Elem +# wrong constant name all_requirements +# wrong constant name conflicting_requirements +# wrong constant name conflicting_requirements= +# wrong constant name requirement_tree +# wrong constant name requirement_tree= +# wrong constant name requirement_trees +# wrong constant name requirement_trees= +# wrong constant name requirements_unwound_to_instead +# wrong constant name requirements_unwound_to_instead= +# wrong constant name reversed_requirement_tree_index +# wrong constant name state_index +# wrong constant name state_index= +# wrong constant name state_requirement +# wrong constant name state_requirement= +# wrong constant name sub_dependencies_to_avoid +# wrong constant name unwinding_to_primary_requirement? +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name dependencies_equal? +# wrong constant name message_with_trees +# wrong constant name specification_provider +# wrong constant name required_ruby_version +# wrong constant name required_rubygems_version +# wrong constant name suggestion +# wrong constant name suggestion= +# wrong constant name +# uninitialized constant Gem::Security::DIGEST_ALGORITHM +# Did you mean? Gem::Security::DIGEST_NAME +# uninitialized constant Gem::Security::DIGEST_ALGORITHM +# Did you mean? Gem::Security::DIGEST_NAME +# 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 +# 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 +# wrong constant name _deprecated_validate_dependencies +# wrong constant name _deprecated_validate_metadata +# wrong constant name _deprecated_validate_permissions +# wrong constant name deleted_gem? +# wrong constant name removed_method_calls +# wrong constant name rg_required_ruby_version= +# wrong constant name to_ruby +# wrong constant name to_yaml +# wrong constant name +# wrong constant name latest_spec_for +# wrong constant name stubs_for_pattern +# 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_duplicate_dependencies +# wrong constant name validate_metadata +# wrong constant name validate_optional +# wrong constant name validate_permissions +# wrong constant name validate_required! +# wrong constant name +# uninitialized constant Gem::Stream +# Did you mean? Gem::StreamUI +# uninitialized constant Gem::Stream +# Did you mean? Gem::StreamUI +# 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 each_strongly_connected_component +# wrong constant name each_strongly_connected_component_from +# wrong constant name strongly_connected_components +# wrong constant name tsort +# wrong constant name tsort_each +# wrong constant name tsort_each_child +# wrong constant name tsort_each_node +# wrong constant name +# wrong constant name each_strongly_connected_component +# wrong constant name each_strongly_connected_component_from +# wrong constant name strongly_connected_components +# wrong constant name tsort +# wrong constant name tsort_each +# wrong constant name spec +# wrong constant name spec= +# wrong constant name +# uninitialized constant Gem::UriParser +# uninitialized constant Gem::UriParser +# uninitialized constant Gem::UriParsing +# uninitialized constant Gem::UriParsing +# wrong constant name _deprecated_silent_system +# wrong constant name activated_gem_paths +# wrong constant name cache_home +# wrong constant name config_home +# wrong constant name data_home +# wrong constant name disable_system_update_message +# wrong constant name disable_system_update_message= +# wrong constant name find_config_file +# wrong constant name plugin_suffix_pattern +# wrong constant name plugin_suffix_regexp +# wrong constant name plugindir +# uninitialized constant GetoptLong +# uninitialized constant GetoptLong +# wrong constant name deconstruct_keys +# wrong constant name ruby2_keywords_hash +# wrong constant name ruby2_keywords_hash? +# Bad color or uninitialized constant BASIC_COLORS +# Bad color or uninitialized constant BLACK +# Bad color or uninitialized constant BLACK_STYLE +# Bad color or uninitialized constant BLINK +# Bad color or uninitialized constant BLINK_STYLE +# Bad color or uninitialized constant BLUE +# Bad color or uninitialized constant BLUE_STYLE +# Bad color or uninitialized constant BOLD +# Bad color or uninitialized constant BOLD_STYLE +# Bad color or uninitialized constant BRIGHT_BLACK +# Bad color or uninitialized constant BRIGHT_BLACK_STYLE +# Bad color or uninitialized constant BRIGHT_BLUE +# Bad color or uninitialized constant BRIGHT_BLUE_STYLE +# Bad color or uninitialized constant BRIGHT_CYAN +# Bad color or uninitialized constant BRIGHT_CYAN_STYLE +# Bad color or uninitialized constant BRIGHT_GRAY +# Bad color or uninitialized constant BRIGHT_GRAY_STYLE +# Bad color or uninitialized constant BRIGHT_GREEN +# Bad color or uninitialized constant BRIGHT_GREEN_STYLE +# Bad color or uninitialized constant BRIGHT_GREY +# Bad color or uninitialized constant BRIGHT_GREY_STYLE +# Bad color or uninitialized constant BRIGHT_MAGENTA +# Bad color or uninitialized constant BRIGHT_MAGENTA_STYLE +# Bad color or uninitialized constant BRIGHT_NONE +# Bad color or uninitialized constant BRIGHT_NONE_STYLE +# Bad color or uninitialized constant BRIGHT_RED +# Bad color or uninitialized constant BRIGHT_RED_STYLE +# Bad color or uninitialized constant BRIGHT_WHITE +# Bad color or uninitialized constant BRIGHT_WHITE_STYLE +# Bad color or uninitialized constant BRIGHT_YELLOW +# Bad color or uninitialized constant BRIGHT_YELLOW_STYLE +# Bad color or uninitialized constant CLEAR +# Bad color or uninitialized constant CLEAR_STYLE +# Bad color or uninitialized constant COLORS +# Bad color or uninitialized constant COLOR_LIST +# Bad color or uninitialized constant CONCEALED +# Bad color or uninitialized constant CONCEALED_STYLE +# Bad color or uninitialized constant CYAN +# Bad color or uninitialized constant CYAN_STYLE +# Bad color or uninitialized constant DARK +# Bad color or uninitialized constant DARK_STYLE +# Bad color or uninitialized constant ERASE_CHAR +# Bad color or uninitialized constant ERASE_CHAR_STYLE +# Bad color or uninitialized constant ERASE_LINE +# Bad color or uninitialized constant ERASE_LINE_STYLE +# Bad color or uninitialized constant GRAY +# Bad color or uninitialized constant GRAY_STYLE +# Bad color or uninitialized constant GREEN +# Bad color or uninitialized constant GREEN_STYLE +# Bad color or uninitialized constant GREY +# Bad color or uninitialized constant GREY_STYLE +# Bad color or uninitialized constant LIGHT_BLACK +# Bad color or uninitialized constant LIGHT_BLACK_STYLE +# Bad color or uninitialized constant LIGHT_BLUE +# Bad color or uninitialized constant LIGHT_BLUE_STYLE +# Bad color or uninitialized constant LIGHT_CYAN +# Bad color or uninitialized constant LIGHT_CYAN_STYLE +# Bad color or uninitialized constant LIGHT_GRAY +# Bad color or uninitialized constant LIGHT_GRAY_STYLE +# Bad color or uninitialized constant LIGHT_GREEN +# Bad color or uninitialized constant LIGHT_GREEN_STYLE +# Bad color or uninitialized constant LIGHT_GREY +# Bad color or uninitialized constant LIGHT_GREY_STYLE +# Bad color or uninitialized constant LIGHT_MAGENTA +# Bad color or uninitialized constant LIGHT_MAGENTA_STYLE +# Bad color or uninitialized constant LIGHT_NONE +# Bad color or uninitialized constant LIGHT_NONE_STYLE +# Bad color or uninitialized constant LIGHT_RED +# Bad color or uninitialized constant LIGHT_RED_STYLE +# Bad color or uninitialized constant LIGHT_WHITE +# Bad color or uninitialized constant LIGHT_WHITE_STYLE +# Bad color or uninitialized constant LIGHT_YELLOW +# Bad color or uninitialized constant LIGHT_YELLOW_STYLE +# Bad color or uninitialized constant MAGENTA +# Bad color or uninitialized constant MAGENTA_STYLE +# Bad color or uninitialized constant NONE +# Bad color or uninitialized constant NONE_STYLE +# Bad color or uninitialized constant ON_BLACK +# Bad color or uninitialized constant ON_BLACK_STYLE +# Bad color or uninitialized constant ON_BLUE +# Bad color or uninitialized constant ON_BLUE_STYLE +# Bad color or uninitialized constant ON_BRIGHT_BLACK +# Bad color or uninitialized constant ON_BRIGHT_BLACK_STYLE +# Bad color or uninitialized constant ON_BRIGHT_BLUE +# Bad color or uninitialized constant ON_BRIGHT_BLUE_STYLE +# Bad color or uninitialized constant ON_BRIGHT_CYAN +# Bad color or uninitialized constant ON_BRIGHT_CYAN_STYLE +# Bad color or uninitialized constant ON_BRIGHT_GRAY +# Bad color or uninitialized constant ON_BRIGHT_GRAY_STYLE +# Bad color or uninitialized constant ON_BRIGHT_GREEN +# Bad color or uninitialized constant ON_BRIGHT_GREEN_STYLE +# Bad color or uninitialized constant ON_BRIGHT_GREY +# Bad color or uninitialized constant ON_BRIGHT_GREY_STYLE +# Bad color or uninitialized constant ON_BRIGHT_MAGENTA +# Bad color or uninitialized constant ON_BRIGHT_MAGENTA_STYLE +# Bad color or uninitialized constant ON_BRIGHT_NONE +# Bad color or uninitialized constant ON_BRIGHT_NONE_STYLE +# Bad color or uninitialized constant ON_BRIGHT_RED +# Bad color or uninitialized constant ON_BRIGHT_RED_STYLE +# Bad color or uninitialized constant ON_BRIGHT_WHITE +# Bad color or uninitialized constant ON_BRIGHT_WHITE_STYLE +# Bad color or uninitialized constant ON_BRIGHT_YELLOW +# Bad color or uninitialized constant ON_BRIGHT_YELLOW_STYLE +# Bad color or uninitialized constant ON_CYAN +# Bad color or uninitialized constant ON_CYAN_STYLE +# Bad color or uninitialized constant ON_GRAY +# Bad color or uninitialized constant ON_GRAY_STYLE +# Bad color or uninitialized constant ON_GREEN +# Bad color or uninitialized constant ON_GREEN_STYLE +# Bad color or uninitialized constant ON_GREY +# Bad color or uninitialized constant ON_GREY_STYLE +# Bad color or uninitialized constant ON_LIGHT_BLACK +# Bad color or uninitialized constant ON_LIGHT_BLACK_STYLE +# Bad color or uninitialized constant ON_LIGHT_BLUE +# Bad color or uninitialized constant ON_LIGHT_BLUE_STYLE +# Bad color or uninitialized constant ON_LIGHT_CYAN +# Bad color or uninitialized constant ON_LIGHT_CYAN_STYLE +# Bad color or uninitialized constant ON_LIGHT_GRAY +# Bad color or uninitialized constant ON_LIGHT_GRAY_STYLE +# Bad color or uninitialized constant ON_LIGHT_GREEN +# Bad color or uninitialized constant ON_LIGHT_GREEN_STYLE +# Bad color or uninitialized constant ON_LIGHT_GREY +# Bad color or uninitialized constant ON_LIGHT_GREY_STYLE +# Bad color or uninitialized constant ON_LIGHT_MAGENTA +# Bad color or uninitialized constant ON_LIGHT_MAGENTA_STYLE +# Bad color or uninitialized constant ON_LIGHT_NONE +# Bad color or uninitialized constant ON_LIGHT_NONE_STYLE +# Bad color or uninitialized constant ON_LIGHT_RED +# Bad color or uninitialized constant ON_LIGHT_RED_STYLE +# Bad color or uninitialized constant ON_LIGHT_WHITE +# Bad color or uninitialized constant ON_LIGHT_WHITE_STYLE +# Bad color or uninitialized constant ON_LIGHT_YELLOW +# Bad color or uninitialized constant ON_LIGHT_YELLOW_STYLE +# Bad color or uninitialized constant ON_MAGENTA +# Bad color or uninitialized constant ON_MAGENTA_STYLE +# Bad color or uninitialized constant ON_NONE +# Bad color or uninitialized constant ON_NONE_STYLE +# Bad color or uninitialized constant ON_RED +# Bad color or uninitialized constant ON_RED_STYLE +# Bad color or uninitialized constant ON_WHITE +# Bad color or uninitialized constant ON_WHITE_STYLE +# Bad color or uninitialized constant ON_YELLOW +# Bad color or uninitialized constant ON_YELLOW_STYLE +# Bad color or uninitialized constant RED +# Bad color or uninitialized constant RED_STYLE +# Bad color or uninitialized constant RESET +# Bad color or uninitialized constant RESET_STYLE +# Bad color or uninitialized constant REVERSE +# Bad color or uninitialized constant REVERSE_STYLE +# Bad color or uninitialized constant STYLES +# Bad color or uninitialized constant STYLE_LIST +# Bad color or uninitialized constant UNDERLINE +# Bad color or uninitialized constant UNDERLINE_STYLE +# Bad color or uninitialized constant UNDERSCORE +# Bad color or uninitialized constant UNDERSCORE_STYLE +# Bad color or uninitialized constant WHITE +# Bad color or uninitialized constant WHITE_STYLE +# Bad color or uninitialized constant YELLOW +# Bad color or uninitialized constant YELLOW_STYLE +# wrong constant name +# 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 set_encoding_by_bom +# wrong constant name wait +# wrong constant name wait_priority +# 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 +# wrong constant name console +# wrong constant name == +# wrong constant name initialize +# uninitialized constant IRB::Abort +# uninitialized constant IRB::Abort +# uninitialized constant IRB::Context +# uninitialized constant IRB::Context +# uninitialized constant IRB::ContextExtender +# uninitialized constant IRB::ContextExtender +# uninitialized constant IRB::ExtendCommandBundle +# uninitialized constant IRB::ExtendCommandBundle +# uninitialized constant IRB::FileInputMethod +# uninitialized constant IRB::FileInputMethod +# uninitialized constant IRB::InputMethod +# uninitialized constant IRB::InputMethod +# uninitialized constant IRB::Inspector +# Did you mean? Insertion +# uninitialized constant IRB::Inspector +# Did you mean? Insertion +# uninitialized constant IRB::Irb +# Did you mean? DRb +# ERB +# uninitialized constant IRB::Irb +# Did you mean? DRb +# ERB +# uninitialized constant IRB::MethodExtender +# uninitialized constant IRB::MethodExtender +# uninitialized constant IRB::ReadlineInputMethod +# uninitialized constant IRB::ReadlineInputMethod +# uninitialized constant IRB::StdioInputMethod +# Did you mean? IRB::StdioOutputMethod +# uninitialized constant IRB::StdioInputMethod +# Did you mean? IRB::StdioOutputMethod +# uninitialized constant IRB::WorkSpace +# uninitialized constant IRB::WorkSpace +# 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 itself +# wrong constant name object_id +# wrong constant name pretty_inspect +# wrong constant name then +# wrong constant name yield_self +# wrong constant name at_exit +# wrong constant name autoload +# 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 +# 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 extra_chain_cert +# wrong constant name extra_chain_cert= +# 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 verify_hostname +# wrong constant name verify_hostname= +# 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 +# uninitialized constant Net::HTTPEarlyHints::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPEarlyHints::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPLoopDetected::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPLoopDetected::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPMisdirectedRequest::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPMisdirectedRequest::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPNotExtended::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPNotExtended::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPPayloadTooLarge::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPPayloadTooLarge::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPProcessing::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPProcessing::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPRangeNotSatisfiable::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPRangeNotSatisfiable::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPURITooLong::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPURITooLong::CODE_TO_OBJ +# wrong constant name +# uninitialized constant Net::HTTPVariantAlsoNegotiates::CODE_CLASS_TO_OBJ +# uninitialized constant Net::HTTPVariantAlsoNegotiates::CODE_TO_OBJ +# wrong constant name +# 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 +# uninitialized constant RUBYGEMS_ACTIVATION_MONITOR +# wrong constant name to_yaml +# wrong constant name yaml_tag +# wrong constant name +# uninitialized constant Observable +# uninitialized constant Observable +# wrong constant name indefinite_length +# wrong constant name indefinite_length= +# wrong constant name +@ +# wrong constant name -@ +# wrong constant name / +# wrong constant name negative? +# wrong constant name << +# wrong constant name concat +# wrong constant name initialize +# wrong constant name +# wrong constant name ccm_data_len= +# wrong constant name set_section +# uninitialized constant OpenSSL::Digest::DSS +# uninitialized constant OpenSSL::Digest::DSS +# uninitialized constant OpenSSL::Digest::DSS1 +# uninitialized constant OpenSSL::Digest::DSS1 +# uninitialized constant OpenSSL::Digest::MD2 +# Did you mean? OpenSSL::Digest::MD4 +# OpenSSL::Digest::MD5 +# uninitialized constant OpenSSL::Digest::MD2 +# Did you mean? OpenSSL::Digest::MD4 +# OpenSSL::Digest::MD5 +# uninitialized constant OpenSSL::Digest::MDC2 +# uninitialized constant OpenSSL::Digest::MDC2 +# 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 == +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name hkdf +# wrong constant name pbkdf2_hmac +# wrong constant name scrypt +# wrong constant name +# wrong constant name _dump +# wrong constant name _load +# wrong constant name +# wrong constant name +# wrong constant name included +# wrong constant name signed? +# uninitialized constant OpenSSL::PKCS5::PKCS5Error +# uninitialized constant OpenSSL::PKCS5::PKCS5Error +# wrong constant name add +# wrong constant name to_octet_string +# wrong constant name oid +# wrong constant name private_to_der +# wrong constant name private_to_pem +# wrong constant name public_to_der +# wrong constant name public_to_pem +# 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 finished_message +# wrong constant name peer_finished_message +# wrong constant name tmp_key +# wrong constant name open +# wrong constant name fileno +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name additional_certs +# wrong constant name additional_certs= +# wrong constant name allowed_digests +# wrong constant name allowed_digests= +# wrong constant name create_timestamp +# wrong constant name default_policy_id +# wrong constant name default_policy_id= +# wrong constant name gen_time +# wrong constant name gen_time= +# wrong constant name serial_number +# wrong constant name serial_number= +# wrong constant name +# wrong constant name algorithm +# wrong constant name algorithm= +# wrong constant name cert_requested= +# wrong constant name cert_requested? +# wrong constant name initialize +# wrong constant name message_imprint +# wrong constant name message_imprint= +# wrong constant name nonce +# wrong constant name nonce= +# wrong constant name policy_id +# wrong constant name policy_id= +# wrong constant name to_der +# wrong constant name version +# wrong constant name version= +# wrong constant name +# wrong constant name failure_info +# wrong constant name initialize +# wrong constant name status +# wrong constant name status_text +# wrong constant name to_der +# wrong constant name token +# wrong constant name token_info +# wrong constant name tsa_certificate +# wrong constant name verify +# wrong constant name +# wrong constant name +# wrong constant name algorithm +# wrong constant name gen_time +# wrong constant name initialize +# wrong constant name message_imprint +# wrong constant name nonce +# wrong constant name ordering +# wrong constant name policy_id +# wrong constant name serial_number +# wrong constant name to_der +# wrong constant name version +# wrong constant name +# wrong constant name +# wrong constant name == +# wrong constant name == +# wrong constant name == +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name value_der +# wrong constant name ca_issuer_uris +# wrong constant name ocsp_uris +# wrong constant name +# wrong constant name authority_key_identifier +# wrong constant name +# wrong constant name crl_uris +# wrong constant name +# wrong constant name find_extension +# wrong constant name +# wrong constant name subject_key_identifier +# 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 fixed_length_secure_compare +# wrong constant name secure_compare +# wrong constant name __id__! +# wrong constant name __send__! +# wrong constant name class! +# wrong constant name clone! +# wrong constant name define_singleton_method! +# wrong constant name delete_field! +# wrong constant name dig! +# wrong constant name display! +# wrong constant name dup! +# wrong constant name each_pair! +# wrong constant name encode_with +# wrong constant name encode_with! +# wrong constant name enum_for! +# wrong constant name extend! +# wrong constant name freeze! +# wrong constant name gem! +# wrong constant name hash! +# wrong constant name init_with +# wrong constant name init_with! +# wrong constant name inspect! +# wrong constant name instance_eval! +# wrong constant name instance_exec! +# wrong constant name instance_variable_get! +# wrong constant name instance_variable_set! +# wrong constant name instance_variables! +# wrong constant name itself! +# wrong constant name marshal_dump! +# wrong constant name method! +# wrong constant name methods! +# wrong constant name object_id! +# wrong constant name private_methods! +# wrong constant name protected_methods! +# wrong constant name public_method! +# wrong constant name public_methods! +# wrong constant name public_send! +# wrong constant name remove_instance_variable! +# wrong constant name send! +# wrong constant name singleton_class! +# wrong constant name singleton_method! +# wrong constant name singleton_methods! +# wrong constant name taint! +# wrong constant name tap! +# wrong constant name then! +# wrong constant name to_enum! +# wrong constant name to_h! +# wrong constant name to_s! +# wrong constant name trust! +# wrong constant name untaint! +# wrong constant name untrust! +# wrong constant name yield_self! +# wrong constant name additional_message +# wrong constant name require_exact +# wrong constant name require_exact= +# 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 +# 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_Version +# Did you mean? 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_Version_C +# Did you mean? 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_Version_R +# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Version_C +# Parser::Ruby24::Racc_Runtime_Version +# Parser::Ruby24::Racc_Runtime_Core_Id_C +# uninitialized constant Parser::Ruby24::Racc_Runtime_Type +# uninitialized constant Parser::Ruby24::Racc_Runtime_Version +# Did you mean? Parser::Ruby24::Racc_Runtime_Core_Version +# uninitialized constant Parser::Ruby24::Racc_YY_Parse_Method +# uninitialized constant Parser::Ruby30::Racc_Main_Parsing_Routine +# uninitialized constant Parser::Ruby30::Racc_Runtime_Core_Id_C +# Did you mean? Parser::Ruby30::Racc_Runtime_Core_Version_C +# uninitialized constant Parser::Ruby30::Racc_Runtime_Core_Version +# Did you mean? Parser::Ruby30::Racc_Runtime_Core_Version_C +# Parser::Ruby30::Racc_Runtime_Core_Version_R +# Parser::Ruby30::Racc_Runtime_Version +# Parser::Ruby30::Racc_Runtime_Core_Id_C +# uninitialized constant Parser::Ruby30::Racc_Runtime_Core_Version_C +# Did you mean? Parser::Ruby30::Racc_Runtime_Core_Version_R +# Parser::Ruby30::Racc_Runtime_Version +# Parser::Ruby30::Racc_Runtime_Core_Id_C +# uninitialized constant Parser::Ruby30::Racc_Runtime_Core_Version_R +# Did you mean? Parser::Ruby30::Racc_Runtime_Core_Version_C +# Parser::Ruby30::Racc_Runtime_Version +# Parser::Ruby30::Racc_Runtime_Core_Id_C +# uninitialized constant Parser::Ruby30::Racc_Runtime_Type +# uninitialized constant Parser::Ruby30::Racc_Runtime_Version +# Did you mean? Parser::Ruby30::Racc_Runtime_Core_Version +# uninitialized constant Parser::Ruby30::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 +# wrong constant name wait +# 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 dispatch_cache +# wrong constant name add_builtin_type +# wrong constant name add_domain_type +# wrong constant name add_tag +# wrong constant name config +# 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 +# wrong constant name safe_load_file +# wrong constant name unsafe_load +# wrong constant name unsafe_load_file +# uninitialized constant RDoc::Constant::RDoc +# Did you mean? RDoc::RDoc +# uninitialized constant RDoc::Constant::RDoc +# Did you mean? RDoc::RDoc +# uninitialized constant RDoc::Markup::Special +# uninitialized constant RDoc::Markup::Special +# uninitialized constant RDoc::RipperStateLex +# uninitialized constant RDoc::RipperStateLex +# wrong constant name language +# wrong constant name language= +# 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::BE_PREDICATE_REGEX +# uninitialized constant RSpec::Core::ExampleGroup::DYNAMIC_MATCHER_REGEX +# uninitialized constant RSpec::Core::ExampleGroup::HAS_REGEX +# 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 +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name ! +# wrong constant name != +# wrong constant name == +# wrong constant name __id__ +# wrong constant name equal? +# wrong constant name +# wrong constant name ractor +# wrong constant name +# wrong constant name +# wrong constant name new +# 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 +# uninitialized constant Random::Base::ALPHANUMERIC +# Did you mean? Random::ALPHANUMERIC +# wrong constant name bytes +# wrong constant name initialize +# wrong constant name seed +# wrong constant name +# wrong constant name bytes +# wrong constant name seed +# 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 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 +# wrong constant name +# 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::EXPR_ARG_ANY +# Ripper::Lexer::EXPR_END_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_ENDARG +# Ripper::EXPR_CMDARG +# Ripper::Lexer::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::Lexer::EXPR_ENDFN +# Ripper::EXPR_ENDFN +# Ripper::EXPR_ENDARG +# Ripper::Lexer::EXPR_CMDARG +# Ripper::EXPR_CMDARG +# 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::EXPR_END_ANY +# Ripper::Lexer::EXPR_END_ANY +# uninitialized constant Ripper::Lexer::EXPR_END_ANY +# Did you mean? Ripper::EXPR_BEG_ANY +# Ripper::Lexer::EXPR_ARG_ANY +# Ripper::Lexer::EXPR_BEG_ANY +# Ripper::EXPR_ARG_ANY +# Ripper::EXPR_END_ANY +# Ripper::Lexer::EXPR_ENDFN +# Ripper::EXPR_ENDFN +# Ripper::EXPR_ENDARG +# Ripper::Lexer::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::EXPR_FNAME +# Ripper::Lexer::EXPR_FNAME +# uninitialized constant Ripper::Lexer::EXPR_VALUE +# Did you mean? Ripper::EXPR_VALUE +# wrong constant name +# 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 +# uninitialized constant Ripper::Lexer::Version +# Did you mean? Ripper::Version +# wrong constant name errors +# wrong constant name lex +# wrong constant name parse +# 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 +# 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 +# wrong constant name [] +# wrong constant name members +# wrong constant name +# 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::EXPR_ARG_ANY +# Ripper::SexpBuilder::EXPR_END_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_ENDARG +# Ripper::EXPR_CMDARG +# Ripper::SexpBuilder::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::SexpBuilder::EXPR_ENDFN +# Ripper::EXPR_ENDFN +# Ripper::EXPR_ENDARG +# Ripper::SexpBuilder::EXPR_CMDARG +# Ripper::EXPR_CMDARG +# 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::EXPR_END_ANY +# Ripper::SexpBuilder::EXPR_END_ANY +# uninitialized constant Ripper::SexpBuilder::EXPR_END_ANY +# Did you mean? Ripper::EXPR_BEG_ANY +# Ripper::SexpBuilder::EXPR_ARG_ANY +# Ripper::SexpBuilder::EXPR_BEG_ANY +# Ripper::EXPR_ARG_ANY +# Ripper::EXPR_END_ANY +# Ripper::SexpBuilder::EXPR_ENDFN +# Ripper::EXPR_ENDFN +# Ripper::EXPR_ENDARG +# Ripper::SexpBuilder::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::EXPR_FNAME +# Ripper::SexpBuilder::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_fndptn +# 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_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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name match +# wrong constant name match_list +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name string +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name compile +# wrong constant name dedent_string +# wrong constant name lex_state_name +# wrong constant name token_match +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name comments +# wrong constant name node_ids +# wrong constant name tokens +# wrong constant name +# 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 +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name do_compile +# wrong constant name +# wrong constant name +# uninitialized constant RuboCop::AST::NodePattern::Compiler::Debug::SequenceSubcompiler::DELTA +# wrong constant name +# wrong constant name enter +# wrong constant name matched? +# wrong constant name success +# wrong constant name +# wrong constant name +# 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_Version +# 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::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_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_Version +# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Id_C +# 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_Core_Version +# uninitialized constant RuboCop::AST::NodePattern::Parser::Racc_YY_Parse_Method +# wrong constant name +# wrong constant name +# wrong constant name +# 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::WithMeta::Racc_Runtime_Core_Version_C +# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C +# 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_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_Core_Version_R +# 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_C +# Did you mean? RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_C +# RuboCop::AST::NodePattern::Parser::WithMeta::Racc_Runtime_Core_Version_R +# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version_R +# RuboCop::AST::NodePattern::Parser::Racc_Runtime_Core_Version +# 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::WithMeta::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::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_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_Core_Version +# RuboCop::AST::NodePattern::Parser::WithMeta::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 +# 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 +# wrong constant name +# 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::NON_PUBLIC_MODIFIERS +# 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 +# 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::DateAssignment::BYTE_ORDER_MARK +# uninitialized constant RuboCop::Cop::Gemspec::DateAssignment::LITERAL_REGEX +# uninitialized constant RuboCop::Cop::Gemspec::DateAssignment::RESTRICT_ON_SEND +# 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 +# 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::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::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::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::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::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 +# 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::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::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::BeEql::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::VisibilityMatcher::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::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::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 +# wrong constant name all +# wrong constant name +# 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::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::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::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::NON_PUBLIC_MODIFIERS +# uninitialized constant RuboCop::Cop::Style::DocumentationMethod::RESTRICT_ON_SEND +# 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::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::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::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::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 +# 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 +# wrong constant name +# 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 pretty_print_children +# wrong constant name +# 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 === +# 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 +# uninitialized constant VERSION +# 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::PRIORITY +# uninitialized constant Socket::RDONLY +# Did you mean? Socket::WRONLY +# uninitialized constant Socket::RDWR +# uninitialized constant Socket::READABLE +# 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 +# uninitialized constant Socket::WRITABLE +# 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 +# wrong constant name name +# wrong constant name from_msgpack_ext +# 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 +# uninitialized constant VERSION +# wrong constant name _close +# wrong constant name call +# wrong constant name initialize +# wrong constant name +# 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 say_error +# uninitialized constant Thor::Shell::Color::DEFAULT_TERMINAL_WIDTH +# wrong constant name are_colors_supported? +# wrong constant name ignore_deadlock +# wrong constant name ignore_deadlock= +# 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 +# uninitialized constant URI::Escape +# Did you mean? URI::ESCAPED +# uninitialized constant URI::Escape +# Did you mean? URI::ESCAPED +# 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::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 +# 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 for +# wrong constant name get_encoding +# wrong constant name open +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name deserialize +# wrong constant name file_extension +# wrong constant name serialize +# wrong constant name +# wrong constant name deserialize +# wrong constant name file_extension +# wrong constant name serialize +# wrong constant name +# wrong constant name deserialize +# wrong constant name file_extension +# wrong constant name serialize +# wrong constant name +# wrong constant name deserialize +# wrong constant name file_extension +# wrong constant name serialize +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name tag +# wrong constant name tags +# wrong constant name cassette_name +# wrong constant name examples_table +# wrong constant name examples_table_row +# wrong constant name feature +# wrong constant name initialize +# wrong constant name scenario +# wrong constant name scenario_outline +# wrong constant name +# wrong constant name +# wrong constant name add_tag +# wrong constant name tags +# uninitialized constant VERSION +# wrong constant name available? +# wrong constant name +# uninitialized constant VERSION +# wrong constant name call +# wrong constant name initialize +# wrong constant name +# wrong constant name configure! +# wrong constant name +# undefined method `method' for class `VCR::Request::FiberAware' +# Did you mean? methods +# uninitialized constant VERSION +# wrong constant name method +# undefined method `method' for class `VCR::Request::Typed' +# Did you mean? methods +# uninitialized constant VERSION +# wrong constant name method +# uninitialized constant Vector +# uninitialized constant Vector +# uninitialized constant WeakRef +# uninitialized constant WeakRef +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name run +# wrong constant name +# 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 +# wrong constant name run +# wrong constant name +# 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 +# wrong constant name run +# wrong constant name +# uninitialized constant YARD::CLI::Graph::DEFAULT_YARDOPTS_FILE +# wrong constant name objects +# wrong constant name options +# wrong constant name run +# wrong constant name +# wrong constant name run +# wrong constant name +# uninitialized constant YARD::CLI::I18n::DEFAULT_YARDOPTS_FILE +# wrong constant name +# wrong constant name run +# wrong constant name +# wrong constant name run +# wrong constant name +# 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 +# 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 +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name inheritance_tree +# wrong constant name inherited_constants +# wrong constant name inherited_meths +# wrong constant name is_exception? +# wrong constant name superclass +# wrong constant name superclass= +# wrong constant name value +# wrong constant name value= +# wrong constant name +# wrong constant name value +# wrong constant name value= +# wrong constant name initialize +# wrong constant name method_missing +# wrong constant name scope +# wrong constant name +# wrong constant name == +# wrong constant name attributes +# wrong constant name attributes= +# wrong constant name contents +# wrong constant name contents= +# wrong constant name eql? +# wrong constant name equal? +# wrong constant name filename +# wrong constant name filename= +# wrong constant name initialize +# wrong constant name locale +# wrong constant name locale= +# wrong constant name name +# wrong constant name name= +# wrong constant name path +# wrong constant name title +# wrong constant name type +# wrong constant name +# wrong constant name attached? +# wrong constant name expand +# wrong constant name macro_data +# wrong constant name macro_data= +# wrong constant name method_object +# wrong constant name method_object= +# wrong constant name +# wrong constant name apply +# wrong constant name apply_macro +# wrong constant name create +# wrong constant name create_docstring +# wrong constant name expand +# wrong constant name find +# wrong constant name find_or_create +# wrong constant name inheritance_tree +# wrong constant name +# wrong constant name aliases +# wrong constant name attributes +# wrong constant name child +# wrong constant name children +# wrong constant name class_attributes +# wrong constant name class_mixins +# wrong constant name constants +# wrong constant name cvars +# wrong constant name groups +# wrong constant name groups= +# wrong constant name included_constants +# wrong constant name included_meths +# wrong constant name initialize +# wrong constant name instance_attributes +# wrong constant name instance_mixins +# wrong constant name meths +# wrong constant name <=> +# wrong constant name == +# wrong constant name === +# wrong constant name equal? +# wrong constant name instance_of? +# wrong constant name is_a? +# wrong constant name kind_of? +# wrong constant name method_missing +# wrong constant name name +# wrong constant name namespace +# wrong constant name parent +# wrong constant name path +# wrong constant name respond_to? +# wrong constant name root? +# wrong constant name title +# wrong constant name to_str +# wrong constant name type +# wrong constant name type= +# wrong constant name === +# wrong constant name +# wrong constant name +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::AliasHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::AliasHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::AliasHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::AttributeHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::AttributeHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::AttributeHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::Base::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::Base::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::C::ClassHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::ClassHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::ClassHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::ConstantHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::ConstantHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::ConstantHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::HandlerMethods::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::HandlerMethods::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::C::InitHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::InitHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::InitHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::MethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::MethodHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::MethodHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::MixinHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::MixinHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::MixinHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::ModuleHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::ModuleHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::ModuleHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::OverrideCommentHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::OverrideCommentHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::OverrideCommentHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::PathHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::PathHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::PathHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::StructHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::StructHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::StructHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::C::SymbolHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::C::SymbolHandler::CSEPQ +# uninitialized constant YARD::Handlers::C::SymbolHandler::PROXY_MATCH +# wrong constant name +# wrong constant name add_predicate_return_tag +# wrong constant name +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::AliasHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::AliasHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::AliasHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::AttributeHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::AttributeHandler::CSEPQ +# 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::NSEPQ +# YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ClassConditionHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::ClassHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ClassHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ClassHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ClassVariableHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ClassVariableHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::CommentHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::CommentHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::CommentHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ConstantHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ConstantHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ConstantHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::DSLHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::DSLHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::DSLHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::DSLHandlerMethods::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::DSLHandlerMethods::PROXY_MATCH +# wrong constant name handle_comments +# wrong constant name register_docstring +# wrong constant name +# wrong constant name process_decorator +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ExceptionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ExceptionHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ExceptionHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ExtendHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ExtendHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ExtendHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::AliasHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::AttributeHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::Base::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::Base::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ClassConditionHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ClassHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ClassVariableHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::CommentHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ConstantHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::DSLHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ExceptionHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ExtendHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::MethodHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::MixinHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::ModuleHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::PrivateConstantHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::VisibilityHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::Legacy::YieldHandler::CSEPQ +# 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 +# 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::NSEPQ +# YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::MethodConditionHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::MethodConditionHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::MethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::MethodHandler::CSEPQ +# 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::NSEPQ +# YARD::Handlers::Ruby::MixinHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::MixinHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::MixinHandler::PROXY_MATCH +# wrong constant name process_mixin +# wrong constant name recipient +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ModuleFunctionHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ModuleFunctionHandler::PROXY_MATCH +# wrong constant name make_module_function +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::ModuleHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::ModuleHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::ModuleHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::PrivateClassMethodHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::PrivateClassMethodHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::PrivateConstantHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::PrivateConstantHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::PublicClassMethodHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::PublicClassMethodHandler::PROXY_MATCH +# wrong constant name +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_ALL +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_CLASSES +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_EXCEPTIONS +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_EXCEPTIONS_HASH +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_EXCEPTIONS_HASH +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::BUILTIN_MODULES +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::CONSTANTMATCH +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::CONSTANTSTART +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::CSEP +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::CSEPQ +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::ISEPQ +# YARD::Handlers::Ruby::StructHandlerMethods::NSEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::ISEP +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::ISEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::ISEPQ +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::NSEPQ +# YARD::Handlers::Ruby::StructHandlerMethods::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::METHODMATCH +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::METHODNAMEMATCH +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::METHODMATCH +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::NAMESPACEMATCH +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::NamespaceMapper +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::NSEP +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::NSEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::NSEPQ +# Did you mean? YARD::Handlers::Ruby::StructHandlerMethods::ISEPQ +# YARD::Handlers::Ruby::StructHandlerMethods::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::StructHandlerMethods::PROXY_MATCH +# wrong constant name add_reader_tags +# wrong constant name add_writer_tags +# wrong constant name create_attributes +# wrong constant name create_class +# wrong constant name create_member_method? +# wrong constant name create_reader +# wrong constant name create_writer +# wrong constant name member_tag_for_member +# wrong constant name members_from_tags +# wrong constant name return_type_from_tag +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::VisibilityHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::VisibilityHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::VisibilityHandler::PROXY_MATCH +# wrong constant name +# 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::NSEPQ +# YARD::Handlers::Ruby::YieldHandler::CSEPQ +# 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::ISEPQ +# YARD::Handlers::Ruby::YieldHandler::CSEPQ +# uninitialized constant YARD::Handlers::Ruby::YieldHandler::PROXY_MATCH +# wrong constant name +# wrong constant name initialize +# wrong constant name load +# wrong constant name name +# wrong constant name translate +# wrong constant name +# 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 +# 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 +# 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 +# wrong constant name extract_messages +# wrong constant name initialize +# wrong constant name translate +# wrong constant name +# wrong constant name << +# 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 backtrace +# wrong constant name capture +# wrong constant name clear_progress +# wrong constant name debug +# wrong constant name enter_level +# wrong constant name initialize +# wrong constant name io +# wrong constant name io= +# wrong constant name print +# wrong constant name progress +# wrong constant name puts +# wrong constant name show_backtraces +# wrong constant name show_backtraces= +# wrong constant name show_progress +# wrong constant name show_progress= +# wrong constant name warn +# wrong constant name warn_no_continuations +# wrong constant name warned +# wrong constant name warned= +# wrong constant name +# wrong constant name instance +# wrong constant name set_token_position +# wrong constant name +# 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 +# wrong constant name initialize +# wrong constant name lookup_by_path +# wrong constant name +# 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 +# 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 +# wrong constant name basepath +# wrong constant name basepath= +# wrong constant name extension +# wrong constant name extension= +# wrong constant name +# wrong constant name initialize +# wrong constant name serialize +# wrong constant name +# wrong constant name initialize +# wrong constant name serialize +# wrong constant name +# 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 +# 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 +# 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 +# uninitialized constant YARD::Server::Commands::DisplayFileCommand::CAN_FORK +# wrong constant name index +# wrong constant name index= +# wrong constant name +# uninitialized constant YARD::Server::Commands::DisplayObjectCommand::CAN_FORK +# wrong constant name index +# wrong constant name +# uninitialized constant YARD::Server::Commands::FramesCommand::CAN_FORK +# wrong constant name +# 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 +# wrong constant name options +# wrong constant name options= +# wrong constant name +# uninitialized constant YARD::Server::Commands::ListCommand::CAN_FORK +# wrong constant name +# 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 +# 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 +# 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 +# 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 +# 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 +# wrong constant name initialize +# wrong constant name +# wrong constant name +# 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 +# wrong constant name +# 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 +# wrong constant name check_static_cache +# wrong constant name +# wrong constant name +# wrong constant name adapter +# wrong constant name adapter= +# wrong constant name do_GET +# wrong constant name initialize +# wrong constant name +# wrong constant name _dump +# wrong constant name initialize +# wrong constant name method_missing +# wrong constant name +# 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 +# wrong constant name defaults +# wrong constant name initialize +# wrong constant name +# wrong constant name initialize +# wrong constant name pair +# wrong constant name pair= +# wrong constant name +# wrong constant name owner +# wrong constant name owner= +# wrong constant name +# 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 +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name initialize +# wrong constant name to_s +# wrong constant name types +# wrong constant name types= +# wrong constant name +# wrong constant name +# 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 +# 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::NSEPQ +# YARD::Tags::TypesExplainer::Parser::CSEPQ +# 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::ISEPQ +# YARD::Tags::TypesExplainer::Parser::CSEPQ +# uninitialized constant YARD::Tags::TypesExplainer::Parser::PROXY_MATCH +# wrong constant name initialize +# wrong constant name parse +# wrong constant name +# wrong constant name parse +# wrong constant name initialize +# wrong constant name name +# wrong constant name name= +# wrong constant name to_s +# wrong constant name +# wrong constant name +# wrong constant name explain +# wrong constant name explain! +# wrong constant name +# 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 +# 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 +# wrong constant name is_class? +# wrong constant name is_method? +# wrong constant name is_module? +# wrong constant name is_namespace? +# wrong constant name +# 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 +# wrong constant name urlencode +# wrong constant name html_syntax_highlight_ruby +# wrong constant name +# wrong constant name fix_typewriter +# wrong constant name +# wrong constant name +# wrong constant name from_path +# wrong constant name from_path= +# wrong constant name initialize +# wrong constant name to_html +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name +# wrong constant name add_html +# wrong constant name add_regexp_handling +# wrong constant name add_word_pair +# wrong constant name attribute_manager +# wrong constant name convert +# wrong constant name initialize +# uninitialized constant RDoc::Markup::AttrChanger::Elem +# wrong constant name turn_off +# wrong constant name turn_off= +# wrong constant name turn_on +# wrong constant name turn_on= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name [] +# wrong constant name initialize +# wrong constant name set_attrs +# wrong constant name +# wrong constant name add_html +# wrong constant name add_regexp_handling +# wrong constant name add_word_pair +# wrong constant name attribute +# wrong constant name attributes +# wrong constant name change_attribute +# wrong constant name changed_attribute_by_name +# wrong constant name convert_attrs +# wrong constant name convert_attrs_matching_word_pairs +# wrong constant name convert_attrs_word_pair_map +# wrong constant name convert_html +# wrong constant name convert_regexp_handlings +# wrong constant name copy_string +# wrong constant name display_attributes +# wrong constant name exclusive? +# wrong constant name exclusive_bitmap +# wrong constant name flow +# wrong constant name html_tags +# wrong constant name mask_protected_sequences +# wrong constant name matching_word_pairs +# wrong constant name protectable +# wrong constant name regexp_handlings +# wrong constant name split_into_flow +# wrong constant name unmask_protected_sequences +# wrong constant name word_pair_map +# wrong constant name +# wrong constant name as_string +# wrong constant name bitmap_for +# wrong constant name each_name_of +# wrong constant name regexp_handling +# wrong constant name +# wrong constant name accept +# wrong constant name +# wrong constant name new +# wrong constant name +# wrong constant name << +# wrong constant name == +# uninitialized constant RDoc::Markup::Document::Elem +# wrong constant name accept +# wrong constant name concat +# wrong constant name each +# wrong constant name empty? +# wrong constant name file +# wrong constant name file= +# wrong constant name initialize +# wrong constant name merge +# wrong constant name merged? +# wrong constant name omit_headings_below +# wrong constant name omit_headings_below= +# wrong constant name parts +# wrong constant name push +# wrong constant name table_of_contents +# wrong constant name +# wrong constant name +# wrong constant name accept_document +# wrong constant name add_regexp_handling_RDOCLINK +# wrong constant name add_regexp_handling_TIDYLINK +# wrong constant name add_tag +# wrong constant name annotate +# wrong constant name convert +# wrong constant name convert_flow +# wrong constant name convert_regexp_handling +# wrong constant name convert_string +# wrong constant name ignore +# wrong constant name in_tt? +# wrong constant name initialize +# wrong constant name off_tags +# wrong constant name on_tags +# wrong constant name parse_url +# wrong constant name tt? +# uninitialized constant RDoc::Markup::Formatter::InlineTag::Elem +# wrong constant name bit +# wrong constant name bit= +# wrong constant name off +# wrong constant name off= +# wrong constant name on +# wrong constant name on= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name +# wrong constant name gen_relative_url +# wrong constant name == +# wrong constant name accept +# wrong constant name +# wrong constant name new +# uninitialized constant RDoc::Markup::Heading::Elem +# wrong constant name accept +# wrong constant name aref +# wrong constant name label +# wrong constant name level +# wrong constant name level= +# wrong constant name plain_html +# wrong constant name text +# wrong constant name text= +# wrong constant name +# wrong constant name [] +# wrong constant name members +# wrong constant name to_html +# wrong constant name to_label +# wrong constant name == +# wrong constant name file +# wrong constant name include_path +# wrong constant name initialize +# wrong constant name +# wrong constant name indent +# wrong constant name initialize +# wrong constant name text +# wrong constant name +# wrong constant name << +# wrong constant name == +# wrong constant name accept +# wrong constant name empty? +# wrong constant name initialize +# wrong constant name items +# wrong constant name last +# wrong constant name push +# wrong constant name type +# wrong constant name type= +# wrong constant name +# wrong constant name << +# wrong constant name == +# wrong constant name accept +# wrong constant name empty? +# wrong constant name initialize +# wrong constant name label +# wrong constant name label= +# wrong constant name length +# wrong constant name parts +# wrong constant name push +# wrong constant name +# wrong constant name text +# wrong constant name +# wrong constant name +# uninitialized constant RDoc::Markup::Parser::MARKUP_FORMAT +# wrong constant name +# wrong constant name +# uninitialized constant RDoc::Markup::Parser::TO_HTML_CHARACTERS +# wrong constant name build_heading +# wrong constant name build_list +# wrong constant name build_paragraph +# wrong constant name build_verbatim +# wrong constant name debug +# wrong constant name debug= +# wrong constant name get +# wrong constant name parse +# wrong constant name parse_text +# wrong constant name peek_token +# wrong constant name setup_scanner +# wrong constant name skip +# wrong constant name tokenize +# wrong constant name tokens +# wrong constant name unget +# wrong constant name +# 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 +# wrong constant name +# wrong constant name +# wrong constant name parse +# wrong constant name tokenize +# wrong constant name find_include_file +# wrong constant name handle +# wrong constant name handle_directive +# wrong constant name include_file +# wrong constant name initialize +# wrong constant name options +# wrong constant name options= +# wrong constant name +# wrong constant name post_process +# wrong constant name post_processors +# wrong constant name register +# wrong constant name registered +# wrong constant name reset +# wrong constant name << +# wrong constant name == +# wrong constant name accept +# wrong constant name initialize +# wrong constant name merge +# wrong constant name parts +# wrong constant name push +# wrong constant name text +# wrong constant name +# wrong constant name == +# wrong constant name initialize +# wrong constant name text +# wrong constant name text= +# wrong constant name type +# wrong constant name +# wrong constant name accept +# wrong constant name +# wrong constant name == +# wrong constant name accept +# wrong constant name align +# wrong constant name align= +# wrong constant name body +# wrong constant name body= +# wrong constant name header +# wrong constant name header= +# wrong constant name initialize +# wrong constant name +# wrong constant name +# wrong constant name +# uninitialized constant RDoc::Markup::ToHtml::MARKUP_FORMAT +# uninitialized constant RDoc::Markup::ToHtml::TO_HTML_CHARACTERS +# wrong constant name accept_blank_line +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_table +# wrong constant name accept_verbatim +# wrong constant name code_object +# wrong constant name code_object= +# wrong constant name convert_string +# wrong constant name end_accepting +# wrong constant name from_path +# wrong constant name from_path= +# wrong constant name gen_url +# wrong constant name handle_RDOCLINK +# 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 +# wrong constant name html_list_name +# wrong constant name in_list_entry +# wrong constant name init_link_notation_regexp_handlings +# wrong constant name init_regexp_handlings +# wrong constant name init_tags +# wrong constant name list +# wrong constant name list_end_for +# wrong constant name list_item_start +# wrong constant name parseable? +# wrong constant name res +# wrong constant name start_accepting +# wrong constant name to_html +# wrong constant name +# 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 context +# wrong constant name context= +# wrong constant name cross_reference +# wrong constant name handle_regexp_CROSSREF +# wrong constant name initialize +# wrong constant name link +# wrong constant name show_hash +# wrong constant name show_hash= +# wrong constant name +# 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 accept_raw +# wrong constant name accept_rule +# wrong constant name add_paragraph +# wrong constant name character_limit +# wrong constant name characters +# wrong constant name handle_regexp_CROSSREF +# wrong constant name initialize +# wrong constant name mask +# wrong constant name paragraph_limit +# wrong constant name paragraphs +# wrong constant name truncate +# wrong constant name +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_table +# wrong constant name accept_verbatim +# wrong constant name end_accepting +# wrong constant name initialize +# wrong constant name start_accepting +# wrong constant name +# wrong constant name accept_blank_line +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_verbatim +# wrong constant name convert +# wrong constant name end_accepting +# 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 res +# wrong constant name start_accepting +# wrong constant name +# wrong constant name gen_url +# wrong constant name handle_rdoc_link +# wrong constant name handle_regexp_RDOCLINK +# wrong constant name handle_regexp_TIDYLINK +# wrong constant name +# wrong constant name accept_blank_line +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_indented_paragraph +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_table +# wrong constant name accept_verbatim +# wrong constant name attributes +# wrong constant name end_accepting +# wrong constant name handle_regexp_HARD_BREAK +# wrong constant name handle_regexp_SUPPRESSED_CROSSREF +# wrong constant name indent +# wrong constant name indent= +# wrong constant name init_tags +# wrong constant name initialize +# wrong constant name list_index +# wrong constant name list_type +# wrong constant name list_width +# wrong constant name prefix +# wrong constant name res +# wrong constant name start_accepting +# wrong constant name use_prefix +# wrong constant name width +# wrong constant name width= +# wrong constant name wrap +# wrong constant name +# wrong constant name accept_blank_line +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_end_bullet +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_table +# wrong constant name accept_verbatim +# wrong constant name end_accepting +# wrong constant name initialize +# wrong constant name omit_headings_below +# wrong constant name omit_headings_below= +# wrong constant name res +# wrong constant name start_accepting +# wrong constant name suppressed? +# wrong constant name +# wrong constant name to_toc +# wrong constant name accept_blank_line +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_verbatim +# wrong constant name end_accepting +# wrong constant name start_accepting +# wrong constant name +# wrong constant name accept_blank_line +# wrong constant name accept_block_quote +# wrong constant name accept_heading +# wrong constant name accept_list_end +# wrong constant name accept_list_item_end +# wrong constant name accept_list_item_start +# wrong constant name accept_list_start +# wrong constant name accept_paragraph +# wrong constant name accept_raw +# wrong constant name accept_rule +# wrong constant name accept_verbatim +# wrong constant name do_nothing +# wrong constant name end_accepting +# wrong constant name initialize +# wrong constant name list_type +# wrong constant name res +# wrong constant name start_accepting +# wrong constant name tt_sections +# wrong constant name +# wrong constant name format +# wrong constant name format= +# wrong constant name normalize +# wrong constant name ruby? +# wrong constant name +# wrong constant name +# wrong constant name parse +# wrong constant name +# 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 +# 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 +# wrong constant name prune_method_listing +# wrong constant name +# 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 +# wrong constant name format_path +# wrong constant name h +# wrong constant name tidy +# wrong constant name uml_visibility +# wrong constant name +# 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 +# wrong constant name +# 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 +# wrong constant name +# 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 +# wrong constant name initialize +# wrong constant name initialize +# wrong constant name zcat +# wrong constant name initialize +# wrong constant name initialize diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi new file mode 100644 index 0000000..0f384cf --- /dev/null +++ b/sorbet/rbi/hidden-definitions/hidden.rbi @@ -0,0 +1,14929 @@ +# 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 + +module Appraisal + VERSION = ::T.let(nil, ::T.untyped) +end + +class Appraisal::Appraisal + DEFAULT_INSTALL_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class Appraisal::BundlerDSL + PARTS = ::T.let(nil, ::T.untyped) +end + +class Appraisal::Command + BUNDLER_ENV_VARS = ::T.let(nil, ::T.untyped) +end + +class Appraisal::Git + def initialize(source, options=T.unsafe(nil)); end +end + +class Appraisal::Git +end + +class Appraisal::Group + def initialize(group_names); end +end + +class Appraisal::Group +end + +class Appraisal::Path + def initialize(source, options=T.unsafe(nil)); end +end + +class Appraisal::Path +end + +class Appraisal::Platform + def initialize(platform_names); end +end + +class Appraisal::Platform +end + +class Appraisal::Source + def initialize(source); end +end + +class Appraisal::Source +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 + + def n_significant_digits(); end + + def precision(); 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 Bootsnap + VERSION = ::T.let(nil, ::T.untyped) +end + +class Bootsnap::CompileCache::Uncompilable +end + +class Bootsnap::CompileCache::Uncompilable +end + +module Bootsnap::ExplicitRequire + ARCHDIR = ::T.let(nil, ::T.untyped) + DLEXT = ::T.let(nil, ::T.untyped) + RUBYLIBDIR = ::T.let(nil, ::T.untyped) +end + +module Bootsnap::LoadPathCache + CACHED_EXTENSIONS = ::T.let(nil, ::T.untyped) + DLEXT = ::T.let(nil, ::T.untyped) + DLEXT2 = ::T.let(nil, ::T.untyped) + DL_EXTENSIONS = ::T.let(nil, ::T.untyped) + DOT_RB = ::T.let(nil, ::T.untyped) + DOT_SO = ::T.let(nil, ::T.untyped) + ERROR_TAG_IVAR = ::T.let(nil, ::T.untyped) + SLASH = ::T.let(nil, ::T.untyped) +end + +class Bootsnap::LoadPathCache::Cache + AGE_THRESHOLD = ::T.let(nil, ::T.untyped) + BUILTIN_FEATURES = ::T.let(nil, ::T.untyped) +end + +class Bootsnap::LoadPathCache::Path + RUBY_LIBDIR = ::T.let(nil, ::T.untyped) + RUBY_SITEDIR = ::T.let(nil, ::T.untyped) + STABLE = ::T.let(nil, ::T.untyped) + VOLATILE = ::T.let(nil, ::T.untyped) +end + +module Bootsnap::LoadPathCache::PathScanner + ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = ::T.let(nil, ::T.untyped) + BUNDLE_PATH = ::T.let(nil, ::T.untyped) + NORMALIZE_NATIVE_EXTENSIONS = ::T.let(nil, ::T.untyped) + REQUIRABLE_EXTENSIONS = ::T.let(nil, ::T.untyped) +end + +class Bootsnap::LoadPathCache::Store + CURRENT_VERSION = ::T.let(nil, ::T.untyped) + VERSION_KEY = ::T.let(nil, ::T.untyped) +end + +class Bundler::APIResponseInvalidDependenciesError + def status_code(); end +end + +class Bundler::APIResponseInvalidDependenciesError +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::CurrentRuby + def jruby_30?(); end + + def jruby_31?(); end + + def jruby_3?(); end + + def maglev_30?(); end + + def maglev_31?(); end + + def maglev_3?(); end + + def mingw_30?(); end + + def mingw_31?(); end + + def mingw_3?(); end + + def mri_30?(); end + + def mri_31?(); end + + def mri_3?(); end + + def mswin64_30?(); end + + def mswin64_31?(); end + + def mswin64_3?(); end + + def mswin_30?(); end + + def mswin_31?(); end + + def mswin_3?(); end + + def on_30?(); end + + def on_31?(); end + + def on_3?(); end + + def rbx_30?(); end + + def rbx_31?(); end + + def rbx_3?(); end + + def ruby_30?(); end + + def ruby_31?(); end + + def ruby_3?(); end + + def truffleruby_30?(); end + + def truffleruby_31?(); end + + def truffleruby_3?(); end + + def x64_mingw_30?(); end + + def x64_mingw_31?(); end + + def x64_mingw_3?(); end +end + +class Bundler::Definition + def dependencies_for(groups); end + + def locked_dependencies(); end + + def most_specific_locked_platform(); end + + def requested_dependencies(); end + + def resolve_only_locally!(); end +end + +class Bundler::Definition + def self.no_lock(); end + + def self.no_lock=(no_lock); end +end + +class Bundler::DepProxy + def clone(); end +end + +class Bundler::DepProxy + def self.get_proxy(dep, platform); end +end + +class Bundler::Dependency + def branch(); end + + def expanded_platforms(); end + + def git(); end + + def github(); end + + def ref(); end +end + +Bundler::Deprecate = Gem::Deprecate + +module Bundler::Digest + SHA1_MASK = ::T.let(nil, ::T.untyped) + SHA1_WORDS = ::T.let(nil, ::T.untyped) +end + +module Bundler::Digest + def self.sha1(string); end +end + +class Bundler::Dsl + def check_primary_source_safety(); end + GITHUB_PULL_REQUEST_URL = ::T.let(nil, ::T.untyped) +end + +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::EnvironmentPreserver + def replace_with_backup(); end +end + +class Bundler::EnvironmentPreserver + def self.env_to_hash(env); end + + def self.from_env(); 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 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 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_checksum(built_gem_path=T.unsafe(nil)); end + + def build_gem(); end + + def built_gem_path(); end + + def clean?(); end + + def committed?(); end + + def current_branch(); end + + def default_remote(); 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 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_prefix=(tag_prefix); 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 + + def self.tag_prefix=(prefix); end +end + +class Bundler::GemHelpers::PlatformMatch + def self.specificity_score(spec_platform, user_platform); end +end + +module Bundler::GemHelpers + def self.local_platform(); end + + def self.same_deps(spec, exemplary_spec); end + + def self.same_specificity(platform, spec, exemplary_spec); 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::Installer + def definition(); end +end + +class Bundler::LazySpecification + def eql?(other); end + + def platform_string(); end +end + +class Bundler::LockfileParser + def self.bundled_with(); end +end + +module Bundler::Molinillo::SpecificationProvider + def dependencies_equal?(dependencies, other_dependencies); end +end + +class Bundler::PermissionError + def parent_folder(); end + + def permission_type(); end +end + +module Bundler::Plugin::API::Source + def ==(other); end + + def add_dependency_names(names); end + + def app_cache_dirname(); end + + def app_cache_path(custom_path=T.unsafe(nil)); 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 identifier(); end + + def include?(other); end + + def initialize(opts); end + + def install(spec, opts); end + + def install_path(); end + + def installed?(); end + + def local!(); 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 spec_names(); 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 + + def unregister_plugin(name); 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::PluginInstallError +end + +class Bundler::Plugin::PluginInstallError +end + +class Bundler::Plugin::SourceList +end + +class Bundler::Plugin::SourceList +end + +module Bundler::Plugin + def self.list(); end + + def self.save_plugin(name, spec, optional_plugin=T.unsafe(nil)); end + + def self.uninstall(names, options); end +end + +class Bundler::ProcessLock +end + +class Bundler::ProcessLock + def self.lock(bundle_path=T.unsafe(nil)); end +end + +class Bundler::RemoteSpecification + def required_rubygems_version(); end +end + +class Bundler::Resolver + include ::Bundler::GemHelpers + def results_for(dependency, base); end + + def source_for(name); end +end + +class Bundler::Resolver::SpecGroup + def activated_platforms(); end + + def activated_platforms=(activated_platforms); end + + def sorted_activated_platforms(); end +end + +class Bundler::Resolver::SpecGroup + def self.create_for(specs, all_platforms, specific_platform); 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::RubygemsIntegration + def add_default_gems_to(specs); end + + 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_bundler(version); end + + def find_name(name); end + + def gem_remote_fetcher(); end + + def load_env_plugins(); end + + def plain_specs(); end + + def plain_specs=(specs); end + + def stub_rubygems(specs); end + + def supports_bundler_trampolining?(); end +end + +class Bundler::SelfManager + def install_locked_bundler_and_restart_with_it_if_needed(); end + + def restart_with_locked_bundler_if_needed(); end + + def update_bundler_and_restart_with_it_if_needed(target); end +end + +class Bundler::SelfManager +end + +class Bundler::Settings + def processor_count(); end + STRING_KEYS = ::T.let(nil, ::T.untyped) +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::Settings + def self.key_for(key); end +end + +class Bundler::Source + def add_dependency_names(names); end + + def cached!(); end + + def identifier(); end + + def local!(); end + + def local_only!(); end + + def remote!(); end + + def spec_names(); end +end + +class Bundler::Source::Git + def glob(); end + + def local?(); end +end + +class Bundler::Source::Rubygems + def default_cache_path_for(dir); end + + def dependency_api_available?(); end + + def multiple_remotes?(); end + + def no_remotes?(); end + + def remote_names(); end +end + +class Bundler::Source::RubygemsAggregate + def identifier(); end + + def initialize(sources, source_map); end + + def source_map(); end + + def sources(); end + + def specs(); end +end + +class Bundler::Source::RubygemsAggregate +end + +class Bundler::SourceList + def add_global_rubygems_remote(uri); end + + def aggregate_global_source?(); end + + def expired_sources?(replacement_sources); end + + def global_path_source(); end + + def implicit_global_source?(); end + + def local_only!(); end + + def lock_other_sources(); end + + def lock_rubygems_sources(); end + + def merged_gem_lockfile_sections!(replacement_source); end + + def merged_gem_lockfile_sections?(); end + + def non_default_explicit_sources(); end + + def non_global_rubygems_sources(); end +end + +class Bundler::SourceMap + def all_requirements(); end + + def dependencies(); end + + def direct_requirements(); end + + def initialize(sources, dependencies, locked_specs); end + + def locked_requirements(); end + + def locked_specs(); end + + def pinned_spec_names(skip=T.unsafe(nil)); end + + def sources(); end +end + +class Bundler::SourceMap +end + +class Bundler::SpecSet + include ::Enumerable + include ::Bundler::TSort + def missing_specs(); end +end + +class Bundler::StubSpecification + def extensions(); end + + def gem_build_complete_path(); end + + def manually_installed?(); end +end + +module Bundler::TSort + def each_strongly_connected_component(&block); end + + def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end + + def strongly_connected_components(); end + + def tsort(); end + + def tsort_each(&block); end + + def tsort_each_child(node); end + + def tsort_each_node(); end +end + +class Bundler::TSort::Cyclic +end + +class Bundler::TSort::Cyclic +end + +module Bundler::TSort + def self.each_strongly_connected_component(each_node, each_child); end + + def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end + + def self.strongly_connected_components(each_node, each_child); end + + def self.tsort(each_node, each_child); end + + def self.tsort_each(each_node, each_child); end +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 except(*keys); 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 + + def unshift(arg, is_value: T.unsafe(nil)); 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_error(*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_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 Bundler::Thor::Shell::Basic +end + +class Bundler::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 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), color=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), color=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 + +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 + 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.for(scheme, *arguments, default: T.unsafe(nil)); 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.configure_gem_home_and_path(path=T.unsafe(nil)); end + + def self.most_specific_locked_platform?(platform); end + + def self.original_exec(*args); end + + def self.original_system(*args); end + + def self.preferred_gemfile_name(); end + + def self.reset_settings_and_root!(); end + + def self.self_manager(); end + + def self.unbundled_env(); end + + def self.unbundled_exec(*args); end + + def self.unbundled_system(*args); end +end + +class CGI + VERSION = ::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 + +module CaseTransform2 + VERSION = ::T.let(nil, ::T.untyped) +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::Encoders::Encoder + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders + +class CodeRay::Encoders::HTML + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) + FILE_EXTENSION = ::T.let(nil, ::T.untyped) + HTML_ESCAPE = ::T.let(nil, ::T.untyped) + HTML_ESCAPE_PATTERN = ::T.let(nil, ::T.untyped) + TOKEN_KIND_TO_INFO = ::T.let(nil, ::T.untyped) + TRANSPARENT_TOKEN_KINDS = ::T.let(nil, ::T.untyped) +end + +class CodeRay::Encoders::HTML::CSS + CSS_CLASS_PATTERN = ::T.let(nil, ::T.untyped) +end + +module CodeRay::Encoders::HTML::Output + DIV = ::T.let(nil, ::T.untyped) + PAGE = ::T.let(nil, ::T.untyped) + SPAN = ::T.let(nil, ::T.untyped) + TABLE = ::T.let(nil, ::T.untyped) +end + +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 + +module CodeRay::PluginHost + PLUGIN_HOSTS = ::T.let(nil, ::T.untyped) + PLUGIN_HOSTS_BY_ID = ::T.let(nil, ::T.untyped) +end + +class CodeRay::Scanners::Java + CONSTANTS = ::T.let(nil, ::T.untyped) + DIRECTIVES = ::T.let(nil, ::T.untyped) + ESCAPE = ::T.let(nil, ::T.untyped) + IDENT = ::T.let(nil, ::T.untyped) + IDENT_KIND = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + MAGIC_VARIABLES = ::T.let(nil, ::T.untyped) + RESERVED = ::T.let(nil, ::T.untyped) + STRING_CONTENT_PATTERN = ::T.let(nil, ::T.untyped) + TYPES = ::T.let(nil, ::T.untyped) + UNICODE_ESCAPE = ::T.let(nil, ::T.untyped) +end + +module CodeRay::Scanners::Java::BuiltinTypes + List = ::T.let(nil, ::T.untyped) +end + +module CodeRay::Scanners::Ruby::Patterns + BINARY = ::T.let(nil, ::T.untyped) + CHARACTER = ::T.let(nil, ::T.untyped) + CLASS_VARIABLE = ::T.let(nil, ::T.untyped) + CONTROL_META_ESCAPE = ::T.let(nil, ::T.untyped) + DATA = ::T.let(nil, ::T.untyped) + DECIMAL = ::T.let(nil, ::T.untyped) + ESCAPE = ::T.let(nil, ::T.untyped) + EXPONENT = ::T.let(nil, ::T.untyped) + FANCY_STRING_INTERPRETED = ::T.let(nil, ::T.untyped) + FANCY_STRING_KIND = ::T.let(nil, ::T.untyped) + FANCY_STRING_START = ::T.let(nil, ::T.untyped) + FLOAT_OR_INT = ::T.let(nil, ::T.untyped) + FLOAT_SUFFIX = ::T.let(nil, ::T.untyped) + GLOBAL_VARIABLE = ::T.let(nil, ::T.untyped) + HEREDOC_OPEN = ::T.let(nil, ::T.untyped) + HEXADECIMAL = ::T.let(nil, ::T.untyped) + IDENT = ::T.let(nil, ::T.untyped) + IDENT_KIND = ::T.let(nil, ::T.untyped) + INSTANCE_VARIABLE = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + KEYWORDS_EXPECTING_VALUE = ::T.let(nil, ::T.untyped) + KEYWORD_NEW_STATE = ::T.let(nil, ::T.untyped) + METHOD_AFTER_DOT = ::T.let(nil, ::T.untyped) + METHOD_NAME = ::T.let(nil, ::T.untyped) + METHOD_NAME_EX = ::T.let(nil, ::T.untyped) + METHOD_NAME_OPERATOR = ::T.let(nil, ::T.untyped) + METHOD_NAME_OR_SYMBOL = ::T.let(nil, ::T.untyped) + METHOD_SUFFIX = ::T.let(nil, ::T.untyped) + NUMERIC = ::T.let(nil, ::T.untyped) + OBJECT_VARIABLE = ::T.let(nil, ::T.untyped) + OCTAL = ::T.let(nil, ::T.untyped) + PREDEFINED_CONSTANTS = ::T.let(nil, ::T.untyped) + PREFIX_VARIABLE = ::T.let(nil, ::T.untyped) + QUOTE_TO_TYPE = ::T.let(nil, ::T.untyped) + REGEXP_MODIFIERS = ::T.let(nil, ::T.untyped) + RUBYDOC = ::T.let(nil, ::T.untyped) + RUBYDOC_OR_DATA = ::T.let(nil, ::T.untyped) + SIMPLE_ESCAPE = ::T.let(nil, ::T.untyped) + SYMBOL = ::T.let(nil, ::T.untyped) + VALUE_FOLLOWS = ::T.let(nil, ::T.untyped) + VARIABLE = ::T.let(nil, ::T.untyped) +end + +class CodeRay::Scanners::Ruby::StringState + CLOSING_PAREN = ::T.let(nil, ::T.untyped) + STRING_PATTERN = ::T.let(nil, ::T.untyped) +end + +class CodeRay::Scanners::Scanner + 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::Styles::Style + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles + +module Commander + VERSION = ::T.let(nil, ::T.untyped) +end + +class Commander::HelpFormatter::Base + def initialize(runner); end + + def render(); end + + def render_command(command); end +end + +class Commander::HelpFormatter::Base +end + +class Commander::HelpFormatter::Terminal + def template(name); end +end + +class Commander::HelpFormatter::Terminal +end + +class Commander::HelpFormatter::TerminalCompact +end + +class Commander::HelpFormatter::TerminalCompact +end + +module Commander::UI::AskForClass + DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped) +end + +module Concurrent + NULL = ::T.let(nil, ::T.untyped) +end + +Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend + +Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile + +module Concurrent::ThreadSafe::Util + CPU_COUNT = ::T.let(nil, ::T.untyped) + FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped) + MAX_INT = ::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 +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.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) + VERSION = ::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 + +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::PlainFormatter + def message_for(corrections); end +end + +class DidYouMean::PlainFormatter +end + +class DidYouMean::RequirePathChecker + def corrections(); end + + def initialize(exception); end + + def path(); end +end + +class DidYouMean::RequirePathChecker + def self.requireables(); end +end + +class DidYouMean::TreeSpellChecker + def augment(); end + + def correct(input); end + + def dictionary(); end + + def dictionary_without_leaves(); end + + def dimensions(); end + + def find_leaves(path); end + + def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end + + def plausible_dimensions(input); end + + def possible_paths(states); end + + def separator(); end + + def tree_depth(); 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 Dotenv::Parser + LINE = ::T.let(nil, ::T.untyped) +end + +module Dry::Configurable + EMPTY_ARRAY = ::T.let(nil, ::T.untyped) + EMPTY_HASH = ::T.let(nil, ::T.untyped) + EMPTY_OPTS = ::T.let(nil, ::T.untyped) + EMPTY_SET = ::T.let(nil, ::T.untyped) + EMPTY_STRING = ::T.let(nil, ::T.untyped) + IDENTITY = ::T.let(nil, ::T.untyped) + Self = ::T.let(nil, ::T.untyped) + Undefined = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Dry::Configurable::DSL + VALID_NAME = ::T.let(nil, ::T.untyped) +end + +class Dry::Configurable::Setting + CLONEABLE_VALUE_TYPES = ::T.let(nil, ::T.untyped) + DEFAULT_CONSTRUCTOR = ::T.let(nil, ::T.untyped) + OPTIONS = ::T.let(nil, ::T.untyped) +end + +class Dry::Configurable::Setting::Nested + CONSTRUCTOR = ::T.let(nil, ::T.untyped) +end + +module Dry::Core::ClassAttributes + EMPTY_ARRAY = ::T.let(nil, ::T.untyped) + EMPTY_HASH = ::T.let(nil, ::T.untyped) + EMPTY_OPTS = ::T.let(nil, ::T.untyped) + EMPTY_SET = ::T.let(nil, ::T.untyped) + EMPTY_STRING = ::T.let(nil, ::T.untyped) + IDENTITY = ::T.let(nil, ::T.untyped) + Self = ::T.let(nil, ::T.untyped) + Undefined = ::T.let(nil, ::T.untyped) +end + +module Dry::Core::Constants + EMPTY_ARRAY = ::T.let(nil, ::T.untyped) + EMPTY_HASH = ::T.let(nil, ::T.untyped) + EMPTY_OPTS = ::T.let(nil, ::T.untyped) + EMPTY_SET = ::T.let(nil, ::T.untyped) + EMPTY_STRING = ::T.let(nil, ::T.untyped) + IDENTITY = ::T.let(nil, ::T.untyped) + Self = ::T.let(nil, ::T.untyped) + Undefined = ::T.let(nil, ::T.untyped) +end + +module Dry::Core::Deprecations + STACK = ::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) + CP720 = ::T.let(nil, ::T.untyped) + IBM720 = ::T.let(nil, ::T.untyped) +end + +class Encoding::Converter + def initialize(*arg); end +end + +class Encoding + def self._load(arg); end +end + +module Enumerable + def sum(*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::Lazy + def eager(); end +end + +class Enumerator::Producer + def each(&blk); end +end + +class Enumerator::Producer +end + +class Enumerator::Yielder + def to_proc(); end +end + +class Enumerator + def self.produce(*arg); end +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 + +module Faraday + CONTENT_TYPE = ::T.let(nil, ::T.untyped) + METHODS_WITH_BODY = ::T.let(nil, ::T.untyped) + METHODS_WITH_QUERY = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Faraday::Adapter + CONTENT_LENGTH = ::T.let(nil, ::T.untyped) + TIMEOUT_KEYS = ::T.let(nil, ::T.untyped) +end + +class Faraday::Adapter::NetHttp + NET_HTTP_EXCEPTIONS = ::T.let(nil, ::T.untyped) +end + +class Faraday::Connection + METHODS = ::T.let(nil, ::T.untyped) + USER_AGENT = ::T.let(nil, ::T.untyped) +end + +module Faraday::DecodeMethods + SUBKEYS_REGEX = ::T.let(nil, ::T.untyped) +end + +class Faraday::Env + ContentLength = ::T.let(nil, ::T.untyped) + MethodsWithBodies = ::T.let(nil, ::T.untyped) + StatusesWithoutBody = ::T.let(nil, ::T.untyped) + SuccessfulStatuses = ::T.let(nil, ::T.untyped) +end + +class Faraday::Logging::Formatter + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +module Faraday::NetHttp + VERSION = ::T.let(nil, ::T.untyped) +end + +class Faraday::RackBuilder + LOCK_ERR = ::T.let(nil, ::T.untyped) + MISSING_ADAPTER_ERROR = ::T.let(nil, ::T.untyped) + NO_ARGUMENT = ::T.let(nil, ::T.untyped) +end + +class Faraday::RackBuilder::Handler + REGISTRY = ::T.let(nil, ::T.untyped) +end + +class Faraday::Request::Authorization + KEY = ::T.let(nil, ::T.untyped) +end + +class Faraday::Request::Json + MIME_TYPE = ::T.let(nil, ::T.untyped) + MIME_TYPE_REGEX = ::T.let(nil, ::T.untyped) +end + +class Faraday::Request::UrlEncoded + CONTENT_TYPE = ::T.let(nil, ::T.untyped) +end + +class Faraday::Response::RaiseError + ClientErrorStatuses = ::T.let(nil, ::T.untyped) + ServerErrorStatuses = ::T.let(nil, ::T.untyped) +end + +module Faraday::Utils + DEFAULT_SEP = ::T.let(nil, ::T.untyped) + ESCAPE_RE = ::T.let(nil, ::T.untyped) +end + +class Faraday::Utils::Headers + KeyMap = ::T.let(nil, ::T.untyped) +end + +class Fiber + def backtrace(*arg); end + + def backtrace_locations(*arg); end + + def blocking?(); end + + def initialize(*arg); end + + def transfer(*arg); end +end + +class Fiber + def self.blocking?(); end + + def self.current(); end + + def self.schedule(*arg); end + + def self.scheduler(); end + + def self.set_scheduler(arg); end +end + +class File + RELATIVE_PARENTDIR = ::T.let(nil, ::T.untyped) + RELATIVE_SAMEDIR = ::T.let(nil, ::T.untyped) +end + +class File + 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 + +class FrozenError + def receiver(); 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.latest_compact_info(); end + + def self.verify_transient_heap_internal_consistency(); end +end + +module Gem + ConfigMap = ::T.let(nil, ::T.untyped) + HAVE_OPENSSL = ::T.let(nil, ::T.untyped) + KERNEL_WARN_IGNORES_INTERNAL_ENTRIES = ::T.let(nil, ::T.untyped) + RbConfigPriorities = ::T.let(nil, ::T.untyped) + RubyGemsVersion = ::T.let(nil, ::T.untyped) + UNTAINT = ::T.let(nil, ::T.untyped) +end + +class Gem::BasicSpecification + def plugins(); end +end + +Gem::Cache = Gem::SourceIndex + +class Gem::ConfigFile + def ipv4_fallback_enabled(); end + + def ipv4_fallback_enabled=(ipv4_fallback_enabled); end + DEFAULT_IPV4_FALLBACK_ENABLED = ::T.let(nil, ::T.untyped) +end + +class Gem::Dependency + def filters_bundler?(); end +end + +class Gem::DependencyList + include ::Gem::TSort +end + +module Gem::Deprecate + def deprecate(name, repl, year, month); end +end + +module Gem::Deprecate + def self.next_rubygems_major_version(); end + + def self.rubygems_deprecate(name, replacement=T.unsafe(nil)); end + + def self.rubygems_deprecate_command(); end +end + +class Gem::Ext::BuildError +end + +class Gem::Ext::BuildError +end + +class Gem::Ext::ExtConfBuilder +end + +class Gem::Ext::ExtConfBuilder + def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), extension_dir=T.unsafe(nil)); end + + def self.get_relative_path(path, base); end +end + +class Gem::Installer + include ::Gem::InstallerUninstallerUtils + def ensure_writable_dir(dir); end + + def gemdeps_load(name); end + + def generate_plugins(); end +end + +Gem::Installer::ExtensionBuildError = Gem::Ext::BuildError + +class Gem::Installer::FakePackage + def copy_to(path); end + + def data_mode(); end + + def data_mode=(data_mode); end + + def dir_mode(); end + + def dir_mode=(dir_mode); end + + def extract_files(destination_dir, pattern=T.unsafe(nil)); end + + def initialize(spec); end + + def prog_mode(); end + + def prog_mode=(prog_mode); end + + def spec(); end + + def spec=(spec); end +end + +class Gem::Installer::FakePackage +end + +class Gem::Installer + def self.inherited(klass); end +end + +module Gem::InstallerUninstallerUtils + def regenerate_plugins_for(spec, plugins_dir); end + + def remove_plugins_for(spec, plugins_dir); end +end + +module Gem::InstallerUninstallerUtils +end + +class Gem::Licenses + LICENSE_REF = ::T.let(nil, ::T.untyped) +end + +class Gem::PathSupport + def home(); end + + def initialize(env); end + + def path(); end + + def spec_cache_dir(); end +end + +class Gem::Platform + def self.match_gem?(platform, gem_name); end + + def self.match_spec?(spec); end +end + +class Gem::Request + extend ::Gem::UserInteraction + extend ::Gem::DefaultUserInteraction + extend ::Gem::Text +end + +class Gem::RequestSet + include ::Gem::TSort +end + +class Gem::Requirement + def _sorted_requirements(); end +end + +class Gem::Resolver::APISet::GemParser + def parse(line); end +end + +class Gem::Resolver::APISet::GemParser +end + +class Gem::Resolver::APISpecification + def self.new(set, api_data); end +end + +class Gem::Resolver::ActivationRequest + def eql?(other); end +end + +class Gem::Resolver::CurrentSet +end + +class Gem::Resolver::CurrentSet +end + +class Gem::Resolver::IndexSpecification + def ==(other); end +end + +class Gem::Resolver::InstallerSet + def force(); end + + def force=(force); end +end + +class Gem::Resolver::LocalSpecification +end + +class Gem::Resolver::LocalSpecification +end + +module Gem::Resolver::Molinillo::Delegates::ResolutionState + def unused_unwind_options(); end +end + +module Gem::Resolver::Molinillo::Delegates::SpecificationProvider + def dependencies_equal?(dependencies, other_dependencies); end +end + +class Gem::Resolver::Molinillo::DependencyGraph + include ::Gem::TSort +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::Resolver::Molinillo::DependencyGraph::Vertex + def _path_to?(other, visited=T.unsafe(nil)); end + + def _recursive_predecessors(vertices=T.unsafe(nil)); end + + def _recursive_successors(vertices=T.unsafe(nil)); end +end + +class Gem::Resolver::Molinillo::ResolutionState + def unused_unwind_options(); end + + def unused_unwind_options=(_); end +end + +class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict + def possibility_set(); end + + def possibility_set=(_); end + + def underlying_error(); end + + def underlying_error=(_); end +end + +class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet + def dependencies(); end + + def dependencies=(_); end + + def latest_version(); end + + def possibilities(); end + + def possibilities=(_); end +end + +class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet + def self.[](*arg); end + + def self.members(); end +end + +class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails + include ::Comparable + def all_requirements(); end + + def conflicting_requirements(); end + + def conflicting_requirements=(_); end + + def requirement_tree(); end + + def requirement_tree=(_); end + + def requirement_trees(); end + + def requirement_trees=(_); end + + def requirements_unwound_to_instead(); end + + def requirements_unwound_to_instead=(_); end + + def reversed_requirement_tree_index(); end + + def state_index(); end + + def state_index=(_); end + + def state_requirement(); end + + def state_requirement=(_); end + + def sub_dependencies_to_avoid(); end + + def unwinding_to_primary_requirement?(); end +end + +class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails + def self.[](*arg); end + + def self.members(); end +end + +module Gem::Resolver::Molinillo::SpecificationProvider + def dependencies_equal?(dependencies, other_dependencies); end +end + +class Gem::Resolver::Molinillo::VersionConflict + include ::Gem::Resolver::Molinillo::Delegates::SpecificationProvider + def message_with_trees(opts=T.unsafe(nil)); end + + def specification_provider(); end +end + +class Gem::Resolver::Specification + def required_ruby_version(); end + + def required_rubygems_version(); end +end + +class Gem::RuntimeRequirementNotMetError + def suggestion(); end + + def suggestion=(suggestion); end +end + +class Gem::RuntimeRequirementNotMetError +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), num_results=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 + include ::Gem::Specification::YamlBackfiller + def _deprecated_validate_dependencies(); end + + def _deprecated_validate_metadata(); end + + def _deprecated_validate_permissions(); end + + def deleted_gem?(); end + + def removed_method_calls(); end + + def rg_required_ruby_version=(req); end + + def to_ruby(); end + LATEST_RUBY_WITHOUT_PATCH_VERSIONS = ::T.let(nil, ::T.untyped) + REMOVED_METHODS = ::T.let(nil, ::T.untyped) +end + +module Gem::Specification::YamlBackfiller + def to_yaml(opts=T.unsafe(nil)); end +end + +module Gem::Specification::YamlBackfiller +end + +class Gem::Specification + extend ::Gem::Deprecate + extend ::Enumerable + def self.latest_spec_for(name); end + + def self.stubs_for_pattern(pattern, match_platform=T.unsafe(nil)); end +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_duplicate_dependencies(); end + + def validate_metadata(); end + + def validate_optional(strict); end + + def validate_permissions(); end + + def validate_required!(); 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::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 + +module Gem::TSort + def each_strongly_connected_component(&block); end + + def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end + + def strongly_connected_components(); end + + def tsort(); end + + def tsort_each(&block); end + + def tsort_each_child(node); end + + def tsort_each_node(); end +end + +module Gem::TSort + def self.each_strongly_connected_component(each_node, each_child); end + + def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end + + def self.strongly_connected_components(each_node, each_child); end + + def self.tsort(each_node, each_child); end + + def self.tsort_each(each_node, each_child); end +end + +class Gem::UninstallError + def spec(); end + + def spec=(spec); end +end + +class Gem::UninstallError +end + +Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError + +module Gem::Util + def self._deprecated_silent_system(*command); end +end + +Gem::Version::Requirement = Gem::Requirement + +module Gem + def self.activated_gem_paths(); end + + def self.cache_home(); end + + def self.config_home(); end + + def self.data_home(); end + + def self.disable_system_update_message(); end + + def self.disable_system_update_message=(disable_system_update_message); end + + def self.find_config_file(); end + + def self.plugin_suffix_pattern(); end + + def self.plugin_suffix_regexp(); end + + def self.plugindir(install_dir=T.unsafe(nil)); 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 HighLine + VERSION = ::T.let(nil, ::T.untyped) +end + +module HighLine::BuiltinStyles + BASIC_COLORS = ::T.let(nil, ::T.untyped) + BLACK = ::T.let(nil, ::T.untyped) + BLACK_STYLE = ::T.let(nil, ::T.untyped) + BLINK = ::T.let(nil, ::T.untyped) + BLINK_STYLE = ::T.let(nil, ::T.untyped) + BLUE = ::T.let(nil, ::T.untyped) + BLUE_STYLE = ::T.let(nil, ::T.untyped) + BOLD = ::T.let(nil, ::T.untyped) + BOLD_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_BLACK = ::T.let(nil, ::T.untyped) + BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_BLUE = ::T.let(nil, ::T.untyped) + BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_CYAN = ::T.let(nil, ::T.untyped) + BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_GRAY = ::T.let(nil, ::T.untyped) + BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_GREEN = ::T.let(nil, ::T.untyped) + BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_GREY = ::T.let(nil, ::T.untyped) + BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped) + BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_NONE = ::T.let(nil, ::T.untyped) + BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_RED = ::T.let(nil, ::T.untyped) + BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_WHITE = ::T.let(nil, ::T.untyped) + BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped) + BRIGHT_YELLOW = ::T.let(nil, ::T.untyped) + BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped) + CLEAR = ::T.let(nil, ::T.untyped) + CLEAR_STYLE = ::T.let(nil, ::T.untyped) + COLORS = ::T.let(nil, ::T.untyped) + COLOR_LIST = ::T.let(nil, ::T.untyped) + CONCEALED = ::T.let(nil, ::T.untyped) + CONCEALED_STYLE = ::T.let(nil, ::T.untyped) + CYAN = ::T.let(nil, ::T.untyped) + CYAN_STYLE = ::T.let(nil, ::T.untyped) + DARK = ::T.let(nil, ::T.untyped) + DARK_STYLE = ::T.let(nil, ::T.untyped) + ERASE_CHAR = ::T.let(nil, ::T.untyped) + ERASE_CHAR_STYLE = ::T.let(nil, ::T.untyped) + ERASE_LINE = ::T.let(nil, ::T.untyped) + ERASE_LINE_STYLE = ::T.let(nil, ::T.untyped) + GRAY = ::T.let(nil, ::T.untyped) + GRAY_STYLE = ::T.let(nil, ::T.untyped) + GREEN = ::T.let(nil, ::T.untyped) + GREEN_STYLE = ::T.let(nil, ::T.untyped) + GREY = ::T.let(nil, ::T.untyped) + GREY_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_BLACK = ::T.let(nil, ::T.untyped) + LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_BLUE = ::T.let(nil, ::T.untyped) + LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_CYAN = ::T.let(nil, ::T.untyped) + LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_GRAY = ::T.let(nil, ::T.untyped) + LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_GREEN = ::T.let(nil, ::T.untyped) + LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_GREY = ::T.let(nil, ::T.untyped) + LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_MAGENTA = ::T.let(nil, ::T.untyped) + LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_NONE = ::T.let(nil, ::T.untyped) + LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_RED = ::T.let(nil, ::T.untyped) + LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_WHITE = ::T.let(nil, ::T.untyped) + LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped) + LIGHT_YELLOW = ::T.let(nil, ::T.untyped) + LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped) + MAGENTA = ::T.let(nil, ::T.untyped) + MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + NONE = ::T.let(nil, ::T.untyped) + NONE_STYLE = ::T.let(nil, ::T.untyped) + ON_BLACK = ::T.let(nil, ::T.untyped) + ON_BLACK_STYLE = ::T.let(nil, ::T.untyped) + ON_BLUE = ::T.let(nil, ::T.untyped) + ON_BLUE_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_BLACK = ::T.let(nil, ::T.untyped) + ON_BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_BLUE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_CYAN = ::T.let(nil, ::T.untyped) + ON_BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GRAY = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GREEN = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GREY = ::T.let(nil, ::T.untyped) + ON_BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped) + ON_BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_NONE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_RED = ::T.let(nil, ::T.untyped) + ON_BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_WHITE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped) + ON_BRIGHT_YELLOW = ::T.let(nil, ::T.untyped) + ON_BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped) + ON_CYAN = ::T.let(nil, ::T.untyped) + ON_CYAN_STYLE = ::T.let(nil, ::T.untyped) + ON_GRAY = ::T.let(nil, ::T.untyped) + ON_GRAY_STYLE = ::T.let(nil, ::T.untyped) + ON_GREEN = ::T.let(nil, ::T.untyped) + ON_GREEN_STYLE = ::T.let(nil, ::T.untyped) + ON_GREY = ::T.let(nil, ::T.untyped) + ON_GREY_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_BLACK = ::T.let(nil, ::T.untyped) + ON_LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_BLUE = ::T.let(nil, ::T.untyped) + ON_LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_CYAN = ::T.let(nil, ::T.untyped) + ON_LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_GRAY = ::T.let(nil, ::T.untyped) + ON_LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_GREEN = ::T.let(nil, ::T.untyped) + ON_LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_GREY = ::T.let(nil, ::T.untyped) + ON_LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_MAGENTA = ::T.let(nil, ::T.untyped) + ON_LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_NONE = ::T.let(nil, ::T.untyped) + ON_LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_RED = ::T.let(nil, ::T.untyped) + ON_LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_WHITE = ::T.let(nil, ::T.untyped) + ON_LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped) + ON_LIGHT_YELLOW = ::T.let(nil, ::T.untyped) + ON_LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped) + ON_MAGENTA = ::T.let(nil, ::T.untyped) + ON_MAGENTA_STYLE = ::T.let(nil, ::T.untyped) + ON_NONE = ::T.let(nil, ::T.untyped) + ON_NONE_STYLE = ::T.let(nil, ::T.untyped) + ON_RED = ::T.let(nil, ::T.untyped) + ON_RED_STYLE = ::T.let(nil, ::T.untyped) + ON_WHITE = ::T.let(nil, ::T.untyped) + ON_WHITE_STYLE = ::T.let(nil, ::T.untyped) + ON_YELLOW = ::T.let(nil, ::T.untyped) + ON_YELLOW_STYLE = ::T.let(nil, ::T.untyped) + RED = ::T.let(nil, ::T.untyped) + RED_STYLE = ::T.let(nil, ::T.untyped) + RESET = ::T.let(nil, ::T.untyped) + RESET_STYLE = ::T.let(nil, ::T.untyped) + REVERSE = ::T.let(nil, ::T.untyped) + REVERSE_STYLE = ::T.let(nil, ::T.untyped) + STYLES = ::T.let(nil, ::T.untyped) + STYLE_LIST = ::T.let(nil, ::T.untyped) + UNDERLINE = ::T.let(nil, ::T.untyped) + UNDERLINE_STYLE = ::T.let(nil, ::T.untyped) + UNDERSCORE = ::T.let(nil, ::T.untyped) + UNDERSCORE_STYLE = ::T.let(nil, ::T.untyped) + WHITE = ::T.let(nil, ::T.untyped) + WHITE_STYLE = ::T.let(nil, ::T.untyped) + YELLOW = ::T.let(nil, ::T.untyped) + YELLOW_STYLE = ::T.let(nil, ::T.untyped) +end + +module HighLine::BuiltinStyles::ClassMethods + RGB_COLOR_PATTERN = ::T.let(nil, ::T.untyped) +end + +class HighLine::SampleColorScheme + SAMPLE_SCHEME = ::T.let(nil, ::T.untyped) +end + +module HighLine::StringExtensions + STYLE_METHOD_NAME_PATTERN = ::T.let(nil, ::T.untyped) +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 set_encoding_by_bom(); end + + def wait(*arg); end + + def wait_priority(*arg); end + + def wait_readable(*arg); end + + def wait_writable(*arg); end + + def winsize(); end + + def winsize=(winsize); end + PRIORITY = ::T.let(nil, ::T.untyped) + READABLE = ::T.let(nil, ::T.untyped) + WRITABLE = ::T.let(nil, ::T.untyped) +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 +end + +class IPAddr + def ==(other); end + + def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end +end + +class Integer + include ::JSON::Ext::Generator::GeneratorMethods::Integer + def to_bn(); end + GMP_VERSION = ::T.let(nil, ::T.untyped) +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 + extend ::Bootsnap::CompileCache::JSON::Patch + 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 itself(); end + + def object_id(); end + + def pretty_inspect(); end + + def then(); end + + def yield_self(); end +end + +module Kernel + def self.at_exit(); end + + def self.autoload(arg, arg1); end +end + +class KeyError + include ::DidYouMean::Correctable +end + +class LoadError + 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 + +module MessagePack::Time + Packer = ::T.let(nil, ::T.untyped) + TIME_AT_3_AVAILABLE = ::T.let(nil, ::T.untyped) + Unpacker = ::T.let(nil, ::T.untyped) +end + +class MessagePack::Timestamp + TIMESTAMP32_MAX_SEC = ::T.let(nil, ::T.untyped) + TIMESTAMP64_MAX_SEC = ::T.let(nil, ::T.untyped) + TYPE = ::T.let(nil, ::T.untyped) +end + +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(*arg, &arg1); 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 extra_chain_cert(); end + + def extra_chain_cert=(extra_chain_cert); end + + 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 verify_hostname(); end + + def verify_hostname=(verify_hostname); end + + def write_timeout(); end + + def write_timeout=(sec); end + ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped) + VERSION = ::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::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError + +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::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError + +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::Protocol + VERSION = ::T.let(nil, ::T.untyped) +end + +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 + +module Open3 + VERSION = ::T.let(nil, ::T.untyped) +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 + +class OpenSSL::Buffering::Buffer + def <<(string); end + + def concat(string); end + + def initialize(); end + BINARY = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::Buffering::Buffer +end + +class OpenSSL::Cipher + def ccm_data_len=(ccm_data_len); end +end + +class OpenSSL::Config + def set_section(section, pairs); end +end + +class OpenSSL::HMAC + def ==(other); 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 + +module OpenSSL::Marshal + def _dump(_level); end +end + +module OpenSSL::Marshal::ClassMethods + def _load(string); end +end + +module OpenSSL::Marshal::ClassMethods +end + +module OpenSSL::Marshal + def self.included(base); end +end + +class OpenSSL::OCSP::Request + def signed?(); end +end + +OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo + +class OpenSSL::PKey::DH + include ::OpenSSL::Marshal +end + +class OpenSSL::PKey::DH + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::PKey::DSA + include ::OpenSSL::Marshal +end + +class OpenSSL::PKey::DSA + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::PKey::EC + include ::OpenSSL::Marshal + EXPLICIT_CURVE = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::PKey::EC::Point + def add(arg); end + + def to_octet_string(arg); end +end + +class OpenSSL::PKey::EC + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::PKey::PKey + def oid(); end + + def private_to_der(*arg); end + + def private_to_pem(*arg); end + + def public_to_der(); end + + def public_to_pem(); end +end + +class OpenSSL::PKey::RSA + include ::OpenSSL::Marshal +end + +class OpenSSL::PKey::RSA + extend ::OpenSSL::Marshal::ClassMethods +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 finished_message(); end + + def peer_finished_message(); end + + def tmp_key(); end +end + +class OpenSSL::SSL::SSLSocket + def self.open(remote_host, remote_port, local_host=T.unsafe(nil), local_port=T.unsafe(nil), context: T.unsafe(nil)); end +end + +module OpenSSL::SSL::SocketForwarder + def fileno(); end +end + +module OpenSSL::Timestamp +end + +class OpenSSL::Timestamp::Factory + def additional_certs(); end + + def additional_certs=(additional_certs); end + + def allowed_digests(); end + + def allowed_digests=(allowed_digests); end + + def create_timestamp(arg, arg1, arg2); end + + def default_policy_id(); end + + def default_policy_id=(default_policy_id); end + + def gen_time(); end + + def gen_time=(gen_time); end + + def serial_number(); end + + def serial_number=(serial_number); end +end + +class OpenSSL::Timestamp::Factory +end + +class OpenSSL::Timestamp::Request + def algorithm(); end + + def algorithm=(algorithm); end + + def cert_requested=(cert_requested); end + + def cert_requested?(); end + + def initialize(*arg); end + + def message_imprint(); end + + def message_imprint=(message_imprint); end + + def nonce(); end + + def nonce=(nonce); end + + def policy_id(); end + + def policy_id=(policy_id); end + + def to_der(); end + + def version(); end + + def version=(version); end +end + +class OpenSSL::Timestamp::Request +end + +class OpenSSL::Timestamp::Response + def failure_info(); end + + def initialize(arg); end + + def status(); end + + def status_text(); end + + def to_der(); end + + def token(); end + + def token_info(); end + + def tsa_certificate(); end + + def verify(*arg); end + GRANTED = ::T.let(nil, ::T.untyped) + GRANTED_WITH_MODS = ::T.let(nil, ::T.untyped) + REJECTION = ::T.let(nil, ::T.untyped) + REVOCATION_NOTIFICATION = ::T.let(nil, ::T.untyped) + REVOCATION_WARNING = ::T.let(nil, ::T.untyped) + WAITING = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::Timestamp::Response +end + +class OpenSSL::Timestamp::TimestampError +end + +class OpenSSL::Timestamp::TimestampError +end + +class OpenSSL::Timestamp::TokenInfo + def algorithm(); end + + def gen_time(); end + + def initialize(arg); end + + def message_imprint(); end + + def nonce(); end + + def ordering(); end + + def policy_id(); end + + def serial_number(); end + + def to_der(); end + + def version(); end +end + +class OpenSSL::Timestamp::TokenInfo +end + +module OpenSSL::Timestamp +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 + include ::OpenSSL::Marshal + def ==(other); end +end + +class OpenSSL::X509::Attribute + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::CRL + include ::OpenSSL::Marshal + include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier + include ::OpenSSL::X509::Extension::Helpers + def ==(other); end +end + +class OpenSSL::X509::CRL + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::Certificate + include ::OpenSSL::Marshal + include ::OpenSSL::X509::Extension::SubjectKeyIdentifier + include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier + include ::OpenSSL::X509::Extension::CRLDistributionPoints + include ::OpenSSL::X509::Extension::AuthorityInfoAccess + include ::OpenSSL::X509::Extension::Helpers +end + +class OpenSSL::X509::Certificate + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::Extension + include ::OpenSSL::Marshal + def ==(other); end + + def value_der(); end +end + +module OpenSSL::X509::Extension::AuthorityInfoAccess + include ::OpenSSL::X509::Extension::Helpers + def ca_issuer_uris(); end + + def ocsp_uris(); end +end + +module OpenSSL::X509::Extension::AuthorityInfoAccess +end + +module OpenSSL::X509::Extension::AuthorityKeyIdentifier + include ::OpenSSL::X509::Extension::Helpers + def authority_key_identifier(); end +end + +module OpenSSL::X509::Extension::AuthorityKeyIdentifier +end + +module OpenSSL::X509::Extension::CRLDistributionPoints + include ::OpenSSL::X509::Extension::Helpers + def crl_uris(); end +end + +module OpenSSL::X509::Extension::CRLDistributionPoints +end + +module OpenSSL::X509::Extension::Helpers + def find_extension(oid); end +end + +module OpenSSL::X509::Extension::Helpers +end + +module OpenSSL::X509::Extension::SubjectKeyIdentifier + include ::OpenSSL::X509::Extension::Helpers + def subject_key_identifier(); end +end + +module OpenSSL::X509::Extension::SubjectKeyIdentifier +end + +class OpenSSL::X509::Extension + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::Name + include ::OpenSSL::Marshal + def to_utf8(); end +end + +class OpenSSL::X509::Name + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::Request + include ::OpenSSL::Marshal + def ==(other); end +end + +class OpenSSL::X509::Request + extend ::OpenSSL::Marshal::ClassMethods +end + +class OpenSSL::X509::Revoked + def ==(other); end + + def to_der(); end +end + +module OpenSSL + def self.fips_mode(); end + + def self.fixed_length_secure_compare(arg, arg1); end + + def self.secure_compare(a, b); end +end + +class OpenStruct + def __id__!(); end + + def __send__!(*arg); end + + def class!(); end + + def clone!(freeze: T.unsafe(nil)); end + + def define_singleton_method!(*arg); end + + def delete_field!(name); end + + def dig!(name, *names); end + + def display!(*arg); end + + def dup!(); end + + def each_pair!(); end + + def encode_with(coder); end + + def encode_with!(coder); end + + def enum_for!(*arg); end + + def extend!(mod, *args); end + + def freeze!(); end + + def gem!(dep, *reqs); end + + def hash!(); end + + def init_with(coder); end + + def init_with!(coder); end + + def inspect!(); end + + def instance_eval!(*arg); end + + def instance_exec!(*arg); end + + def instance_variable_get!(arg); end + + def instance_variable_set!(arg, arg1); end + + def instance_variables!(); end + + def itself!(); end + + def marshal_dump!(); end + + def method!(arg); end + + def methods!(*arg); end + + def object_id!(); end + + def private_methods!(*arg); end + + def protected_methods!(*arg); end + + def public_method!(arg); end + + def public_methods!(*arg); end + + def public_send!(*arg); end + + def remove_instance_variable!(arg); end + + def send!(*arg); end + + def singleton_class!(); end + + def singleton_method!(arg); end + + def singleton_methods!(*arg); end + + def taint!(); end + + def tap!(); end + + def then!(); end + + def to_enum!(*arg); end + + def to_h!(&block); end + + def to_s!(); end + + def trust!(); end + + def untaint!(); end + + def untrust!(); end + + def yield_self!(); end + VERSION = ::T.let(nil, ::T.untyped) +end + +class OptionParser + def additional_message(typ, opt); end + + def require_exact(); end + + def require_exact=(require_exact); end + Version = ::T.let(nil, ::T.untyped) +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 + +class Parlour::ConflictResolver + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Conversion::Converter + extend ::T::Private::Abstract::Hooks + extend ::T::InterfaceWrapper::Helpers + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +module Parlour::Debugging::Tree + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +module Parlour::Debugging + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Generator + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Options + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::ParseError + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Plugin + extend ::T::Private::Abstract::Hooks + extend ::T::InterfaceWrapper::Helpers + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::RbiGenerator::Parameter + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::RbiGenerator::StructProp + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::RbsGenerator::Block + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::RbsGenerator::MethodSignature + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::RbsGenerator::Parameter + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +module Parlour::TypeLoader + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::TypeParser::NodePath + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::TypeParser + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::TypedObject + extend ::T::Private::Abstract::Hooks + extend ::T::InterfaceWrapper::Helpers + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Types::Proc::Parameter + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +end + +class Parlour::Types::Type + extend ::T::Private::Abstract::Hooks + extend ::T::InterfaceWrapper::Helpers + extend ::T::Private::Methods::MethodHooks + extend ::T::Private::Methods::SingletonMethodHooks +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 + +Parser::CurrentRuby = Parser::Ruby30 + +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::Ruby30 + 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::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 Process::Status + def self.wait(*arg); 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::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::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 + +class Psych::Visitors::Visitor + def self.dispatch_cache(); end +end + +module Psych + extend ::Bootsnap::CompileCache::YAML::Patch + 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.config(); end + + def self.domain_types(*args, &block); end + + def self.domain_types=(*args, &block); end + + def self.dump_tags(*args, &block); end + + def self.dump_tags=(*args, &block); end + + def self.libyaml_version(); end + + def self.load_tags(*args, &block); end + + def self.load_tags=(*args, &block); end + + def self.remove_type(type_tag); end + + def self.safe_load_file(filename, **kwargs); end + + def self.unsafe_load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil), freeze: T.unsafe(nil)); end + + def self.unsafe_load_file(filename, **kwargs); end +end + +module RDoc::Text + def language(); end + + def language=(language); 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 + include ::RSpec::Core::MockingAdapters::RSpec + include ::RSpec::Mocks::ExampleMethods + include ::RSpec::Mocks::ArgumentMatchers + include ::RSpec::Mocks::ExampleMethods::ExpectHost + include ::RSpec::Matchers + 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 + +class RSpec::Expectations::MultipleExpectationsNotMetError + include ::RSpec::Core::MultipleExceptionError::InterfaceTag +end + +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::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::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::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_Extensions = ::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_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_Type = ::T.let(nil, ::T.untyped) + Racc_Runtime_Version = ::T.let(nil, ::T.untyped) + Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped) +end + +class Ractor::ClosedError +end + +class Ractor::ClosedError +end + +class Ractor::Error +end + +class Ractor::Error +end + +class Ractor::IsolationError +end + +class Ractor::IsolationError +end + +class Ractor::MovedError +end + +class Ractor::MovedError +end + +class Ractor::MovedObject + def !(*arg); end + + def !=(*arg); end + + def ==(*arg); end + + def __id__(*arg); end + + def equal?(*arg); end +end + +class Ractor::MovedObject +end + +class Ractor::RemoteError + def ractor(); end +end + +class Ractor::RemoteError +end + +class Ractor::UnsafeError +end + +class Ractor::UnsafeError +end + +class Ractor + def self.new(*args, name: T.unsafe(nil), &block); end +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 + +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::Base + include ::Random::Formatter + def bytes(arg); end + + def initialize(*arg); end + + def seed(); end +end + +class Random::Base + extend ::Random::Formatter +end + +class Random + def self.bytes(arg); end + + def self.seed(); 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 + +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 + +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 Resolv::IPv6 + Regex_8HexLinkLocal = ::T.let(nil, ::T.untyped) + Regex_CompressedHexLinkLocal = ::T.let(nil, ::T.untyped) +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(**kw); end + + def parse(raise_errors: T.unsafe(nil)); end + + def scan(**kw); end + + def tokenize(**kw); 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_fndptn(*args); 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_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_10_10 = ::T.let(nil, ::T.untyped) + SET_1_1 = ::T.let(nil, ::T.untyped) + SET_1_2 = ::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_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_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_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_DESCRIBE_FEATURE = ::T.let(nil, ::T.untyped) + SET_DOUBLE_SPY = ::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_EXPECT_ALLOW = ::T.let(nil, ::T.untyped) + SET_FACTORYGIRL_FACTORYBOT = ::T.let(nil, ::T.untyped) + SET_FIRST_LAST__ETC = ::T.let(nil, ::T.untyped) + SET_FIXNUM_BIGNUM = ::T.let(nil, ::T.untyped) + SET_FORMAT_SPRINTF_PRINTF = ::T.let(nil, ::T.untyped) + SET_GSUB_GSUB = ::T.let(nil, ::T.untyped) + SET_INCLUDE_EXTEND_PREPEND = ::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_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_NEW_ = ::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_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_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_SPAWN_SYSTEM = ::T.let(nil, ::T.untyped) + SET_SPRINTF_FORMAT = ::T.let(nil, ::T.untyped) + SET_STRUCT_CLASS = ::T.let(nil, ::T.untyped) + SET_SUCC_PRED_NEXT = ::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_ZERO_POSITIVE_NEGATIVE = ::T.let(nil, ::T.untyped) + SET__ = ::T.let(nil, ::T.untyped) + SET__AT_SLICE = ::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___EQL = ::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 + +module RuboCop::AST::RuboCopCompatibility + INCOMPATIBLE_COPS = ::T.let(nil, ::T.untyped) +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::Config + DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ConfigLoader + 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::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::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 + +module RuboCop::Cop::DefNode + NON_PUBLIC_MODIFIERS = ::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::DateAssignment + MSG = ::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 + 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::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 + 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::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 + MSG = ::T.let(nil, ::T.untyped) +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::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 + 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::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::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 + 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::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 + +class RuboCop::Cop::Metrics::AbcSize + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::BlockLength + 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 + COUNTED_NODES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::MethodLength + 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::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::BeEql + 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::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::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::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::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::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 + +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 + +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 + 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 + 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::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_DEFAULT_NIL = ::T.let(nil, ::T.untyped) + MSG_DEFAULT_RHS_MULTILINE_BLOCK = ::T.let(nil, ::T.untyped) + MSG_DEFAULT_RHS_SECOND_ARG_OF_FETCH = ::T.let(nil, ::T.untyped) + MSG_DEFAULT_RHS_SINGLE_LINE_BLOCK = ::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::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 + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses + 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 + 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 + DELIMITER_REGEXP = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NumericPredicate + 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 + 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 + +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 + +class RuboCop::RemoteConfig + CACHE_LIFETIME = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ResultCache + NON_CHANGING = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Runner + MAX_ITERATIONS = ::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) + MSG = ::T.let(nil, ::T.untyped) + STRING = ::T.let(nil, ::T.untyped) +end + +class RubyVM::AbstractSyntaxTree::Node + def pretty_print_children(q, names=T.unsafe(nil)); end +end + +class RubyVM::InstructionSequence + extend ::Bootsnap::CompileCache::ISeq::InstructionSequenceMixin +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::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::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 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 + VERSION = ::T.let(nil, ::T.untyped) +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 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 + +class Symbol + def name(); end +end + +class Symbol + def self.from_msgpack_ext(data); end +end + +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 + +module Thor::RakeCompat + include ::Rake::DSL + include ::Rake::FileUtilsExt +end + +class Thor::Shell::Basic + def say_error(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end +end + +class Thor::Shell::Color + def are_colors_supported?(); end +end + +class Thread + def self.ignore_deadlock(); end + + def self.ignore_deadlock=(ignore_deadlock); end +end + +module Timeout + VERSION = ::T.let(nil, ::T.untyped) +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 + def self.for(scheme, *arguments, default: T.unsafe(nil)); end + + 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 VCR + CassetteMutex = ::T.let(nil, ::T.untyped) + MainThread = ::T.let(nil, ::T.untyped) +end + +class VCR::Cassette + VALID_RECORD_MODES = ::T.let(nil, ::T.untyped) +end + +module VCR::Cassette::Serializers::Compressed + def deserialize(string); end + + def file_extension(); end + + def serialize(hash); end +end + +module VCR::Cassette::Serializers::Compressed + extend ::VCR::Cassette::Serializers::Compressed +end + +module VCR::Cassette::Serializers::Psych + def deserialize(string); end + + def file_extension(); end + + def serialize(hash); end + ENCODING_ERRORS = ::T.let(nil, ::T.untyped) +end + +module VCR::Cassette::Serializers::Psych + extend ::VCR::Cassette::Serializers::Psych + extend ::VCR::Cassette::EncodingErrorHandling +end + +module VCR::Cassette::Serializers::Syck + def deserialize(string); end + + def file_extension(); end + + def serialize(hash); end + ENCODING_ERRORS = ::T.let(nil, ::T.untyped) +end + +module VCR::Cassette::Serializers::Syck + extend ::VCR::Cassette::Serializers::Syck + extend ::VCR::Cassette::EncodingErrorHandling +end + +module VCR::Cassette::Serializers::YAML + def deserialize(string); end + + def file_extension(); end + + def serialize(hash); end + ENCODING_ERRORS = ::T.let(nil, ::T.untyped) +end + +module VCR::Cassette::Serializers::YAML + extend ::VCR::Cassette::Serializers::YAML + extend ::VCR::Cassette::EncodingErrorHandling +end + +class VCR::CucumberTags + def initialize(main_object); end + + def tag(*tag_names); end + + def tags(*tag_names); end +end + +class VCR::CucumberTags::ScenarioNameBuilder + def cassette_name(); end + + def examples_table(*arg); end + + def examples_table_row(row); end + + def feature(feature); end + + def initialize(test_case); end + + def scenario(*arg); end + + def scenario_outline(feature); end +end + +class VCR::CucumberTags::ScenarioNameBuilder +end + +class VCR::CucumberTags + def self.add_tag(tag); end + + def self.tags(); end +end + +class VCR::Errors::UnhandledHTTPRequestError + ALL_SUGGESTIONS = ::T.let(nil, ::T.untyped) +end + +class VCR::HTTPInteraction::HookAware + RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) +end + +module VCR::InternetConnection + def available?(); end + EXAMPLE_HOST = ::T.let(nil, ::T.untyped) +end + +module VCR::InternetConnection + extend ::VCR::InternetConnection +end + +class VCR::LinkedCassette + RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) +end + +class VCR::Middleware::Rack + include ::VCR::VariableArgsBlockCaller + def call(env); end + + def initialize(app, &block); end +end + +class VCR::Middleware::Rack +end + +module VCR::RSpec::Metadata + def configure!(); end +end + +module VCR::RSpec::Metadata + extend ::VCR::RSpec::Metadata +end + +class VCR::Request::FiberAware + RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) +end + +class VCR::Request::Typed + RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) +end + +class VCR::RequestIgnorer + LOCALHOST_ALIASES = ::T.let(nil, ::T.untyped) +end + +class VCR::RequestMatcherRegistry + DEFAULT_MATCHERS = ::T.let(nil, ::T.untyped) +end + +class VCR::Response + HAVE_ZLIB = ::T.let(nil, ::T.untyped) +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::CodeObjects::ClassObject + def inheritance_tree(include_mods=T.unsafe(nil)); end + + def inherited_constants(); end + + def inherited_meths(opts=T.unsafe(nil)); end + + def is_exception?(); end + + def superclass(); end + + def superclass=(object); end +end + +class YARD::CodeObjects::ClassVariableObject + def value(); end + + def value=(value); end +end + +class YARD::CodeObjects::ClassVariableObject +end + +class YARD::CodeObjects::ConstantObject + def value(); end + + def value=(value); end +end + +class YARD::CodeObjects::ExtendedMethodObject + def initialize(obj); end + + def method_missing(sym, *args, &block); end + + def scope(); end +end + +class YARD::CodeObjects::ExtendedMethodObject +end + +class YARD::CodeObjects::ExtraFileObject + def ==(other); end + + def attributes(); end + + def attributes=(attributes); end + + def contents(); end + + def contents=(contents); end + + def eql?(other); end + + def equal?(other); end + + def filename(); end + + def filename=(filename); end + + def initialize(filename, contents=T.unsafe(nil)); end + + def locale(); end + + def locale=(locale); end + + def name(); end + + def name=(name); end + + def path(); end + + def title(); end + + def type(); end +end + +class YARD::CodeObjects::ExtraFileObject +end + +class YARD::CodeObjects::MacroObject + def attached?(); end + + def expand(call_params=T.unsafe(nil), full_source=T.unsafe(nil), block_source=T.unsafe(nil)); end + + def macro_data(); end + + def macro_data=(macro_data); end + + def method_object(); end + + def method_object=(method_object); end + MACRO_MATCH = ::T.let(nil, ::T.untyped) +end + +class YARD::CodeObjects::MacroObject + def self.apply(docstring, call_params=T.unsafe(nil), full_source=T.unsafe(nil), block_source=T.unsafe(nil), _method_object=T.unsafe(nil)); end + + def self.apply_macro(macro, docstring, call_params=T.unsafe(nil), full_source=T.unsafe(nil), block_source=T.unsafe(nil)); end + + def self.create(macro_name, data, method_object=T.unsafe(nil)); end + + def self.create_docstring(macro_name, data, method_object=T.unsafe(nil)); end + + def self.expand(macro_data, call_params=T.unsafe(nil), full_source=T.unsafe(nil), block_source=T.unsafe(nil)); end + + def self.find(macro_name); end + + def self.find_or_create(macro_name, data, method_object=T.unsafe(nil)); end +end + +class YARD::CodeObjects::ModuleObject + def inheritance_tree(include_mods=T.unsafe(nil)); end +end + +class YARD::CodeObjects::ModuleObject +end + +class YARD::CodeObjects::NamespaceObject + def aliases(); end + + def attributes(); end + + def child(opts=T.unsafe(nil)); end + + def children(); end + + def class_attributes(); end + + def class_mixins(); end + + def constants(opts=T.unsafe(nil)); end + + def cvars(); end + + def groups(); end + + def groups=(groups); end + + def included_constants(); end + + def included_meths(opts=T.unsafe(nil)); end + + def initialize(namespace, name, *args, &block); end + + def instance_attributes(); end + + def instance_mixins(); end + + def meths(opts=T.unsafe(nil)); end +end + +class YARD::CodeObjects::Proxy + def ==(other); end + + def ===(other); end + + def equal?(other); end + + def instance_of?(klass); end + + def is_a?(klass); end + + def kind_of?(klass); end + + def method_missing(meth, *args, &block); end + + def name(prefix=T.unsafe(nil)); end + + def namespace(); end + + def parent(); end + + def path(); end + + def respond_to?(meth, include_private=T.unsafe(nil)); end + + def root?(); end + + def title(); end + + def to_str(); end + + def type(); end + + def type=(type); end +end + +class YARD::CodeObjects::Proxy + def self.===(other); end +end + +class YARD::CodeObjects::ProxyMethodError +end + +class YARD::CodeObjects::ProxyMethodError +end + +class YARD::CodeObjects::RootObject +end + +class YARD::CodeObjects::RootObject +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 ::YARD::Handlers::Ruby::StructHandlerMethods +end + +class YARD::Handlers::Ruby::ClassHandler +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 + def process_mixin(mixin); end + + def recipient(mixin); end +end + +class YARD::Handlers::Ruby::MixinHandler +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 + +module YARD::Handlers::Ruby::StructHandlerMethods + include ::YARD::CodeObjects + 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=T.unsafe(nil)); end + + def create_reader(klass, member); end + + def create_writer(klass, member); end + + def member_tag_for_member(klass, member, type=T.unsafe(nil)); end + + def members_from_tags(klass); end + + def return_type_from_tag(member_tag); end +end + +module YARD::Handlers::Ruby::StructHandlerMethods +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 + def <<(msg=T.unsafe(nil)); end + + def backtrace(exc, level_meth=T.unsafe(nil)); end + + def capture(msg, nontty_log=T.unsafe(nil)); end + + def clear_progress(); end + + def debug(*args); end + + def enter_level(new_level=T.unsafe(nil)); end + + def initialize(pipe, *args); end + + def io(); end + + def io=(pipe); end + + def print(msg=T.unsafe(nil)); end + + def progress(msg, nontty_log=T.unsafe(nil)); end + + def puts(msg=T.unsafe(nil)); end + + def show_backtraces(); end + + def show_backtraces=(show_backtraces); end + + def show_progress(); end + + def show_progress=(show_progress); end + + def warn(*args); end + + def warn_no_continuations(); end + + def warned(); end + + def warned=(warned); end + PROGRESS_INDICATORS = ::T.let(nil, ::T.untyped) +end + +class YARD::Logger + def self.instance(pipe=T.unsafe(nil)); end +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::Parser::SourceParser + DEFAULT_PATH_GLOB = ::T.let(nil, ::T.untyped) + ENCODING_BYTE_ORDER_MARKS = ::T.let(nil, ::T.untyped) + ENCODING_LINE = ::T.let(nil, ::T.untyped) + FROZEN_STRING_LINE = ::T.let(nil, ::T.untyped) + SHEBANG_LINE = ::T.let(nil, ::T.untyped) +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 + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP + def add_html(tag, name); end + + def add_regexp_handling(pattern, name); end + + def add_word_pair(start, stop, name); end + + def attribute_manager(); end + + def convert(input, formatter); end + + def initialize(attribute_manager=T.unsafe(nil)); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttrChanger + def turn_off(); end + + def turn_off=(_); end + + def turn_on(); end + + def turn_on=(_); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttrChanger + def self.[](*arg); end + + def self.members(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttrSpan + def [](n); end + + def initialize(length, exclusive); end + + def set_attrs(start, length, bits); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttrSpan +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttributeManager + def add_html(tag, name, exclusive=T.unsafe(nil)); end + + def add_regexp_handling(pattern, name, exclusive=T.unsafe(nil)); end + + def add_word_pair(start, stop, name, exclusive=T.unsafe(nil)); end + + def attribute(turn_on, turn_off); end + + def attributes(); end + + def change_attribute(current, new); end + + def changed_attribute_by_name(current_set, new_set); end + + def convert_attrs(str, attrs, exclusive=T.unsafe(nil)); end + + def convert_attrs_matching_word_pairs(str, attrs, exclusive); end + + def convert_attrs_word_pair_map(str, attrs, exclusive); end + + def convert_html(str, attrs, exclusive=T.unsafe(nil)); end + + def convert_regexp_handlings(str, attrs, exclusive=T.unsafe(nil)); end + + def copy_string(start_pos, end_pos); end + + def display_attributes(); end + + def exclusive?(attr); end + + def exclusive_bitmap(); end + + def flow(str); end + + def html_tags(); end + + def mask_protected_sequences(); end + + def matching_word_pairs(); end + + def protectable(); end + + def regexp_handlings(); end + + def split_into_flow(); end + + def unmask_protected_sequences(); end + + def word_pair_map(); end + A_PROTECT = ::T.let(nil, ::T.untyped) + NON_PRINTING_END = ::T.let(nil, ::T.untyped) + NON_PRINTING_START = ::T.let(nil, ::T.untyped) + NULL = ::T.let(nil, ::T.untyped) + PROTECT_ATTR = ::T.let(nil, ::T.untyped) +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::AttributeManager +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Attributes + def as_string(bitmap); end + + def bitmap_for(name); end + + def each_name_of(bitmap); end + + def regexp_handling(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Attributes +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::BlankLine + def accept(visitor); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::BlankLine + def self.new(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::BlockQuote +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::BlockQuote +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Document + include ::Enumerable + def <<(part); end + + def ==(other); end + + def accept(visitor); end + + def concat(parts); end + + def each(&block); end + + def empty?(); end + + def file(); end + + def file=(location); end + + def initialize(*parts); end + + def merge(other); end + + def merged?(); end + + def omit_headings_below(); end + + def omit_headings_below=(omit_headings_below); end + + def parts(); end + + def push(*parts); end + + def table_of_contents(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Document +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter + def accept_document(document); end + + def add_regexp_handling_RDOCLINK(); end + + def add_regexp_handling_TIDYLINK(); end + + def add_tag(name, start, stop); end + + def annotate(tag); end + + def convert(content); end + + def convert_flow(flow); end + + def convert_regexp_handling(target); end + + def convert_string(string); end + + def ignore(*node); end + + def in_tt?(); end + + def initialize(options, markup=T.unsafe(nil)); end + + def off_tags(res, item); end + + def on_tags(res, item); end + + def parse_url(url); end + + def tt?(tag); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter::InlineTag + def bit(); end + + def bit=(_); end + + def off(); end + + def off=(_); end + + def on(); end + + def on=(_); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter::InlineTag + def self.[](*arg); end + + def self.members(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Formatter + def self.gen_relative_url(path, target); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::HardBreak + def ==(other); end + + def accept(visitor); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::HardBreak + def self.new(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Heading + def accept(visitor); end + + def aref(); end + + def label(context=T.unsafe(nil)); end + + def level(); end + + def level=(_); end + + def plain_html(); end + + def text(); end + + def text=(_); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Heading + def self.[](*arg); end + + def self.members(); end + + def self.to_html(); end + + def self.to_label(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Include + def ==(other); end + + def file(); end + + def include_path(); end + + def initialize(file, include_path); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Include +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::IndentedParagraph + def indent(); end + + def initialize(indent, *parts); end + + def text(hard_break=T.unsafe(nil)); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::IndentedParagraph +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::List + def <<(item); end + + def ==(other); end + + def accept(visitor); end + + def empty?(); end + + def initialize(type=T.unsafe(nil), *items); end + + def items(); end + + def last(); end + + def push(*items); end + + def type(); end + + def type=(type); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::List +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ListItem + def <<(part); end + + def ==(other); end + + def accept(visitor); end + + def empty?(); end + + def initialize(label=T.unsafe(nil), *parts); end + + def label(); end + + def label=(label); end + + def length(); end + + def parts(); end + + def push(*parts); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ListItem +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Paragraph + def text(hard_break=T.unsafe(nil)); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Paragraph +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser + include ::RDoc::Text + def build_heading(level); end + + def build_list(margin); end + + def build_paragraph(margin); end + + def build_verbatim(margin); end + + def debug(); end + + def debug=(debug); end + + def get(); end + + def parse(parent, indent=T.unsafe(nil)); end + + def parse_text(parent, indent); end + + def peek_token(); end + + def setup_scanner(input); end + + def skip(token_type, error=T.unsafe(nil)); end + + def tokenize(input); end + + def tokens(); end + + def unget(); end + LIST_TOKENS = ::T.let(nil, ::T.untyped) +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser::Error +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser::Error +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::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 YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser::MyStringScanner +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser::ParseError +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser::ParseError +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Parser + def self.parse(str); end + + def self.tokenize(str); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::PreProcess + def find_include_file(name); end + + def handle(text, code_object=T.unsafe(nil), &block); end + + def handle_directive(prefix, directive, param, code_object=T.unsafe(nil), encoding=T.unsafe(nil)); end + + def include_file(name, indent, encoding); end + + def initialize(input_file_name, include_path); end + + def options(); end + + def options=(options); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::PreProcess + def self.post_process(&block); end + + def self.post_processors(); end + + def self.register(directive, &block); end + + def self.registered(); end + + def self.reset(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Raw + def <<(text); end + + def ==(other); end + + def accept(visitor); end + + def initialize(*parts); end + + def merge(other); end + + def parts(); end + + def push(*texts); end + + def text(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Raw +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::RegexpHandling + def ==(o); end + + def initialize(type, text); end + + def text(); end + + def text=(text); end + + def type(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::RegexpHandling +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule + def accept(visitor); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Rule +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Table + def ==(other); end + + def accept(visitor); end + + def align(); end + + def align=(align); end + + def body(); end + + def body=(body); end + + def header(); end + + def header=(header); end + + def initialize(header, align, body); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Table +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToAnsi +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToAnsi +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToBs +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToBs +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtml + include ::RDoc::Text + def accept_blank_line(blank_line); end + + def accept_block_quote(block_quote); end + + def accept_heading(heading); end + + def accept_list_end(list); end + + def accept_list_item_end(list_item); end + + def accept_list_item_start(list_item); end + + def accept_list_start(list); end + + def accept_paragraph(paragraph); end + + def accept_raw(raw); end + + def accept_rule(rule); end + + def accept_table(header, body, aligns); end + + def accept_verbatim(verbatim); end + + def code_object(); end + + def code_object=(code_object); end + + def convert_string(text); end + + def end_accepting(); end + + def from_path(); end + + def from_path=(from_path); end + + def gen_url(url, text); end + + def handle_RDOCLINK(url); end + + 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 + + def html_list_name(list_type, open_tag); end + + def in_list_entry(); end + + def init_link_notation_regexp_handlings(); end + + def init_regexp_handlings(); end + + def init_tags(); end + + def list(); end + + def list_end_for(list_type); end + + def list_item_start(list_item, list_type); end + + def parseable?(text); end + + def res(); end + + def start_accepting(); end + + def to_html(item); end + LIST_TYPE_TO_HTML = ::T.let(nil, ::T.untyped) +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtml +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlCrossref + def context(); end + + def context=(context); end + + def cross_reference(name, text=T.unsafe(nil), code=T.unsafe(nil)); end + + def handle_regexp_CROSSREF(target); end + + def initialize(options, from_path, context, markup=T.unsafe(nil)); end + + def link(name, text, code=T.unsafe(nil)); end + + def show_hash(); end + + def show_hash=(show_hash); end + ALL_CROSSREF_REGEXP = ::T.let(nil, ::T.untyped) + CLASS_REGEXP_STR = ::T.let(nil, ::T.untyped) + CROSSREF_REGEXP = ::T.let(nil, ::T.untyped) + METHOD_REGEXP_STR = ::T.let(nil, ::T.untyped) +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlCrossref +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlSnippet + def accept_raw(*node); end + + def accept_rule(*node); end + + def add_paragraph(); end + + def character_limit(); end + + def characters(); end + + def handle_regexp_CROSSREF(target); end + + def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end + + def mask(); end + + def paragraph_limit(); end + + def paragraphs(); end + + def truncate(text); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToHtmlSnippet +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToJoinedParagraph + def accept_block_quote(*node); end + + def accept_heading(*node); end + + def accept_list_end(*node); end + + def accept_list_item_end(*node); end + + def accept_list_item_start(*node); end + + def accept_list_start(*node); end + + def accept_paragraph(paragraph); end + + def accept_raw(*node); end + + def accept_rule(*node); end + + def accept_table(*node); end + + def accept_verbatim(*node); end + + def end_accepting(); end + + def initialize(); end + + def start_accepting(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToJoinedParagraph +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToLabel + def accept_blank_line(*node); end + + def accept_block_quote(*node); end + + def accept_heading(*node); end + + def accept_list_end(*node); end + + def accept_list_item_end(*node); end + + def accept_list_item_start(*node); end + + def accept_list_start(*node); end + + def accept_paragraph(*node); end + + def accept_raw(*node); end + + def accept_rule(*node); end + + def accept_verbatim(*node); end + + def convert(text); end + + def end_accepting(*node); end + + 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 + + def res(); end + + def start_accepting(*node); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToLabel +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToMarkdown + def gen_url(url, text); end + + def handle_rdoc_link(url); end + + def handle_regexp_RDOCLINK(target); end + + def handle_regexp_TIDYLINK(target); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToMarkdown +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToRdoc + def accept_blank_line(blank_line); end + + def accept_block_quote(block_quote); end + + def accept_heading(heading); end + + def accept_indented_paragraph(paragraph); end + + def accept_list_end(list); end + + def accept_list_item_end(list_item); end + + def accept_list_item_start(list_item); end + + def accept_list_start(list); end + + def accept_paragraph(paragraph); end + + def accept_raw(raw); end + + def accept_rule(rule); end + + def accept_table(header, body, aligns); end + + def accept_verbatim(verbatim); end + + def attributes(text); end + + def end_accepting(); end + + def handle_regexp_HARD_BREAK(target); end + + def handle_regexp_SUPPRESSED_CROSSREF(target); end + + def indent(); end + + def indent=(indent); end + + def init_tags(); end + + def initialize(markup=T.unsafe(nil)); end + + def list_index(); end + + def list_type(); end + + def list_width(); end + + def prefix(); end + + def res(); end + + def start_accepting(); end + + def use_prefix(); end + + def width(); end + + def width=(width); end + + def wrap(text); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToRdoc +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTableOfContents + def accept_blank_line(*node); end + + def accept_block_quote(*node); end + + def accept_heading(heading); end + + def accept_list_end(*node); end + + def accept_list_end_bullet(*node); end + + def accept_list_item_end(*node); end + + def accept_list_item_start(*node); end + + def accept_list_start(*node); end + + def accept_paragraph(*node); end + + def accept_raw(*node); end + + def accept_rule(*node); end + + def accept_table(*node); end + + def accept_verbatim(*node); end + + def end_accepting(); end + + def initialize(); end + + def omit_headings_below(); end + + def omit_headings_below=(omit_headings_below); end + + def res(); end + + def start_accepting(); end + + def suppressed?(heading); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTableOfContents + def self.to_toc(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTest + def accept_blank_line(blank_line); end + + def accept_heading(heading); end + + def accept_list_end(list); end + + def accept_list_item_end(list_item); end + + def accept_list_item_start(list_item); end + + def accept_list_start(list); end + + def accept_paragraph(paragraph); end + + def accept_raw(raw); end + + def accept_rule(rule); end + + def accept_verbatim(verbatim); end + + def end_accepting(); end + + def start_accepting(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTest +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTtOnly + def accept_blank_line(markup_item); end + + def accept_block_quote(block_quote); end + + def accept_heading(markup_item); end + + def accept_list_end(list); end + + def accept_list_item_end(markup_item); end + + def accept_list_item_start(list_item); end + + def accept_list_start(list); end + + def accept_paragraph(paragraph); end + + def accept_raw(markup_item); end + + def accept_rule(markup_item); end + + def accept_verbatim(markup_item); end + + def do_nothing(markup_item); end + + def end_accepting(); end + + def initialize(markup=T.unsafe(nil)); end + + def list_type(); end + + def res(); end + + def start_accepting(); end + + def tt_sections(text); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::ToTtOnly +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Verbatim + def format(); end + + def format=(format); end + + def normalize(); end + + def ruby?(); end +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP::Verbatim +end + +class YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP + def self.parse(str); end +end + +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 + +class Zlib::Deflate + def initialize(*arg); end +end + +class Zlib::GzipReader + def initialize(*arg); end +end + +class Zlib::GzipReader + def self.zcat(*arg); end +end + +class Zlib::GzipWriter + def initialize(*arg); end +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 new file mode 100644 index 0000000..b63a9fb --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/bundler-audit/all/bundler-audit.rbi @@ -0,0 +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/bundler-audit/all/bundler-audit.rbi +# +# typed: strict + +class Bundler::Audit::Task < ::Rake::TaskLib +end diff --git a/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi b/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi new file mode 100644 index 0000000..b3f7389 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/faraday/all/faraday.rbi @@ -0,0 +1,82 @@ +# 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/faraday/all/faraday.rbi +# +# typed: strict + +module Faraday + def self.new(url = nil, options = nil, &block); end + + # HTTP verb methods. These are proxied to Faraday::Connecation, + # which should have corresponding sigs + + # Query methods + sig do + params( + url: String, + params: T.nilable(T::Hash[Object, Object]), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.get(url, params = nil, headers = nil, &block); end + sig do + params( + url: String, + params: T.nilable(T::Hash[Object, Object]), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.head(url, params = nil, headers = nil, &block); end + sig do + params( + url: String, + params: T.nilable(T::Hash[Object, Object]), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.delete(url, params = nil, headers = nil, &block); end + sig do + params( + url: String, + params: T.nilable(T::Hash[Object, Object]), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.trace(url, params = nil, headers = nil, &block); end + + # Body methods + sig do + params( + url: String, + body: T.any(String, T.nilable(T::Hash[Object, Object])), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.post(url, body = nil, headers = nil, &block); end + sig do + params( + url: String, + body: T.any(String, T.nilable(T::Hash[Object, Object])), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.put(url, body = nil, headers = nil, &block); end + sig do + params( + url: String, + body: T.any(String, T.nilable(T::Hash[Object, Object])), + headers: T.nilable(T::Hash[Object, String]), + block: T.nilable(T.proc.params(req: Faraday::Request).void), + ).returns(Faraday::Response) + end + def self.patch(url, body = nil, headers = nil, &block); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi new file mode 100644 index 0000000..abbae7b --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi @@ -0,0 +1,276 @@ +# 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 + +module Rainbow + sig { returns(T::Boolean) } + attr_accessor :enabled + + class Color + sig { returns(Symbol) } + attr_reader :ground + + sig do + params( + ground: Symbol, + values: T.any([Integer], [Integer, Integer, Integer]) + ).returns(Color) + end + def self.build(ground, values); end + + sig { params(hex: String).returns([Integer, Integer, Integer]) } + def self.parse_hex_color(hex); end + + class Indexed < Color + sig { returns(Integer) } + attr_reader :num + + sig { params(ground: Symbol, num: Integer).void } + def initialize(ground, num); end + + sig { returns(T::Array[Integer]) } + def codes; end + end + + class Named < Indexed + NAMES = T.let(nil, T::Hash[Symbol, Integer]) + + 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 + sig { returns(Integer) } + attr_accessor :r, :g, :b + + sig { params(value: Numeric).returns(Integer) } + def to_ansi_domain(value); end + + sig { params(ground: Symbol, values: Integer).void } + def initialize(ground, *values); end + + sig { returns(T::Array[Integer]) } + def codes; end + end + + class X11Named < RGB + include X11ColorNames + + 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 + end + + sig { returns(Wrapper) } + def self.global; end + + sig { returns(T::Boolean) } + def self.enabled; end + + sig { params(value: T::Boolean).returns(T::Boolean) } + def self.enabled=(value); end + + sig { params(string: String).returns(String) } + def self.uncolor(string); end + + class NullPresenter < String + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def color(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def foreground(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def fg(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def background(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def bg(*values); end + + sig { returns(NullPresenter) } + def reset; end + + sig { returns(NullPresenter) } + def bright; end + + sig { returns(NullPresenter) } + def faint; end + + sig { returns(NullPresenter) } + def italic; end + + sig { returns(NullPresenter) } + def underline; end + + sig { returns(NullPresenter) } + def blink; end + + sig { returns(NullPresenter) } + def inverse; end + + sig { returns(NullPresenter) } + def hide; end + + sig { returns(NullPresenter) } + def cross_out; end + + sig { returns(NullPresenter) } + def black; end + + sig { returns(NullPresenter) } + def red; end + + sig { returns(NullPresenter) } + def green; end + + sig { returns(NullPresenter) } + def yellow; end + + sig { returns(NullPresenter) } + def blue; end + + sig { returns(NullPresenter) } + def magenta; end + + sig { returns(NullPresenter) } + def cyan; end + + sig { returns(NullPresenter) } + def white; end + + sig { returns(NullPresenter) } + def bold; end + + sig { returns(NullPresenter) } + def dark; end + + sig { returns(NullPresenter) } + def strike; end + end + + class Presenter < String + TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer]) + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def color(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def foreground(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def fg(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def background(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def bg(*values); end + + sig { returns(Presenter) } + def reset; end + + sig { returns(Presenter) } + def bright; end + + sig { returns(Presenter) } + def faint; end + + sig { returns(Presenter) } + def italic; end + + sig { returns(Presenter) } + def underline; end + + sig { returns(Presenter) } + def blink; end + + sig { returns(Presenter) } + def inverse; end + + sig { returns(Presenter) } + def hide; end + + sig { returns(Presenter) } + def cross_out; end + + sig { returns(Presenter) } + def black; end + + sig { returns(Presenter) } + def red; end + + sig { returns(Presenter) } + def green; end + + sig { returns(Presenter) } + def yellow; end + + sig { returns(Presenter) } + def blue; end + + sig { returns(Presenter) } + def magenta; end + + sig { returns(Presenter) } + def cyan; end + + sig { returns(Presenter) } + def white; end + + sig { returns(Presenter) } + def bold; end + + sig { returns(Presenter) } + def dark; end + + sig { returns(Presenter) } + def strike; end + end + + class StringUtils + sig { params(string: String, codes: T::Array[Integer]).returns(String) } + def self.wrap_with_sgr(string, codes); end + + sig { params(string: String).returns(String) } + def uncolor(string); end + end + + VERSION = T.let(nil, String) + + class Wrapper + sig { returns(T::Boolean) } + attr_accessor :enabled + + sig { params(enabled: T::Boolean).void } + def initialize(enabled = true); end + + sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) } + def wrap(string); end + end + + module X11ColorNames + NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]]) + end +end + +sig { params(string: String).returns(Rainbow::Presenter) } +def Rainbow(string); end diff --git a/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi b/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi new file mode 100644 index 0000000..4ac93ac --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi @@ -0,0 +1,645 @@ +# 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 new file mode 100644 index 0000000..f11b3ec --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi @@ -0,0 +1,24 @@ +# 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/>=1.8/rubocop.rbi b/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi new file mode 100644 index 0000000..8c3fd24 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/rubocop/>=1.8/rubocop.rbi @@ -0,0 +1,12 @@ +# 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 new file mode 100644 index 0000000..0238e1b --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/thor/all/thor.rbi @@ -0,0 +1,905 @@ +# 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 new file mode 100644 index 0000000..47476a2 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/yard/all/yard.rbi @@ -0,0 +1,32 @@ +# 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/spec/client_spec.rb b/spec/client_spec.rb index bbddd0b..bd67a29 100644 --- a/spec/client_spec.rb +++ b/spec/client_spec.rb @@ -1,3 +1,4 @@ +# typed: false # frozen_string_literal: true RSpec.describe FirebaseDynamicLink::Client do @@ -6,34 +7,34 @@ let(:connection_failed_class) do Class.new do def post(*) - raise Faraday::ConnectionFailed, 'test' + raise Faraday::ConnectionFailed, "test" end end end let(:timout_error_class) do Class.new do def post(*) - raise Faraday::TimeoutError, 'test' + raise Faraday::TimeoutError, "test" end end end before do FirebaseDynamicLink.configure do |config| - config.api_key = ENV['API_KEY'] - config.dynamic_link_domain = ENV['DYNAMIC_LINK_DOMAIN'] + config.api_key = ENV["API_KEY"] + config.dynamic_link_domain = ENV["DYNAMIC_LINK_DOMAIN"] end end - describe '#shorten_link' do - shared_examples 'short link created correctly' do |api_key_location| - context 'when faraday default adapter is not defined' do - it 'raises error' do + describe "#shorten_link" do + shared_examples "short link created correctly" do |api_key_location| + context "when faraday default adapter is not defined" do + it "raises error" do if FirebaseDynamicLink::USE_FARADAY_2 Faraday.default_adapter = nil - link = 'http://saiqulhaq.com' - options = { suffix_option: 'SHORT' } + link = "http://saiqulhaq.com" + options = {suffix_option: "SHORT"} expect { subject.shorten_link(link, options) }.to raise_error @@ -43,69 +44,69 @@ def post(*) end end - context 'when faraday default adapter is defined' do + context "when faraday default adapter is defined" do before do Faraday.default_adapter = :net_http if FirebaseDynamicLink::USE_FARADAY_2 end - it 'shorten link correctly' do - link = 'http://saiqulhaq.com' - VCR.use_cassette("shorten_link-SHORT-#{ENV['BUNDLE_GEMFILE']}-#{api_key_location}") do - options = { suffix_option: 'SHORT' } + it "shorten link correctly" do + link = "http://saiqulhaq.com" + VCR.use_cassette("shorten_link-SHORT-#{ENV["BUNDLE_GEMFILE"]}-#{api_key_location}") do + options = {suffix_option: "SHORT"} result = subject.shorten_link(link, options) - expect(result[:link]).not_to eq('') + expect(result[:link]).not_to eq("") expect(result[:link]).not_to eq(link) end - VCR.use_cassette("shorten_link-UNGUESSABLE-#{ENV['BUNDLE_GEMFILE']}-#{api_key_location}") do - options = { suffix_option: 'UNGUESSABLE', timout: 5 } + VCR.use_cassette("shorten_link-UNGUESSABLE-#{ENV["BUNDLE_GEMFILE"]}-#{api_key_location}") do + options = {suffix_option: "UNGUESSABLE", timout: 5} result = subject.shorten_link(link, options) - expect(result[:link]).not_to eq('') + expect(result[:link]).not_to eq("") expect(result[:link]).not_to eq(link) end end end end - include_examples 'short link created correctly', :global + include_examples "short link created correctly", :global - context 'with api_key provided to constructor' do - subject { described_class.new(api_key: ENV['API_KEY']) } + context "with api_key provided to constructor" do + subject { described_class.new(api_key: ENV["API_KEY"]) } before do FirebaseDynamicLink.reset_config FirebaseDynamicLink.configure do |config| - config.api_key = 'i am not valid api key' - config.dynamic_link_domain = ENV['DYNAMIC_LINK_DOMAIN'] + config.api_key = "i am not valid api key" + config.dynamic_link_domain = ENV["DYNAMIC_LINK_DOMAIN"] end end - include_examples 'short link created correctly', :local + include_examples "short link created correctly", :local end - it 'raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised' do + it "raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised" do allow_any_instance_of(described_class).to receive(:connection).and_return(connection_failed_class.new) expect do - subject.shorten_link('http://saiqulhaq.com') + subject.shorten_link("http://saiqulhaq.com") end.to raise_error(FirebaseDynamicLink::ConnectionError) end - it 'raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised' do + it "raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised" do allow_any_instance_of(described_class).to receive(:connection).and_return(timout_error_class.new) expect do - subject.shorten_link('http://saiqulhaq.com') + subject.shorten_link("http://saiqulhaq.com") end.to raise_error(FirebaseDynamicLink::ConnectionError) end end - describe '#shorten_parameters' do - let(:link) { 'http://saiqulhaq.com/asldkj' } + describe "#shorten_parameters" do + let(:link) { "http://saiqulhaq.com/asldkj" } let(:parameters) do - string = 'foo' + string = "foo" { link: link, android_info: { - android_package_name: 'com.foo.name' + android_package_name: "com.foo.name" }, ios_info: { ios_bundle_id: string, @@ -120,7 +121,7 @@ def post(*) }, analytics_info: { google_play_analytics: { - utm_source: 'custom' + utm_source: "custom" }, itunes_connect_analytics: { at: string @@ -134,13 +135,13 @@ def post(*) } end - context 'when faraday default adapter is not defined' do - it 'raises error' do + context "when faraday default adapter is not defined" do + it "raises error" do if FirebaseDynamicLink::USE_FARADAY_2 Faraday.default_adapter = nil - link = 'http://saiqulhaq.com' - options = { suffix_option: 'SHORT' } + link = "http://saiqulhaq.com" + options = {suffix_option: "SHORT"} expect { subject.shorten_parameters(parameters, options) }.to raise_error @@ -150,47 +151,47 @@ def post(*) end end - context 'when faraday default adapter is defined' do + context "when faraday default adapter is defined" do before do Faraday.default_adapter = :net_http if FirebaseDynamicLink::USE_FARADAY_2 end - it 'shorten link correctly' do - VCR.use_cassette("shorten_parameters-SHORT-#{ENV['BUNDLE_GEMFILE']}") do + it "shorten link correctly" do + VCR.use_cassette("shorten_parameters-SHORT-#{ENV["BUNDLE_GEMFILE"]}") do options = { - suffix_option: 'SHORT' + suffix_option: "SHORT" # dynamic_link_domain: 'foo' # optional } expect do result = subject.shorten_parameters(parameters, options) - expect(result[:link]).not_to eq('') + expect(result[:link]).not_to eq("") expect(result[:link]).not_to eq(link) end.not_to raise_error end - VCR.use_cassette("shorten_parameters-UNGUESSABLE-#{ENV['BUNDLE_GEMFILE']}") do + VCR.use_cassette("shorten_parameters-UNGUESSABLE-#{ENV["BUNDLE_GEMFILE"]}") do options = { - suffix_option: 'UNGUESSABLE' + suffix_option: "UNGUESSABLE" # dynamic_link_domain: 'foo' # optional } expect do result = subject.shorten_parameters(parameters, options) - expect(result[:link]).not_to eq('') + expect(result[:link]).not_to eq("") expect(result[:link]).not_to eq(link) end.not_to raise_error end end - it 'raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised' do + it "raise FirebaseDynamicLink::ConnectionError if Faraday::ConnectionFailed raised" do allow_any_instance_of(described_class).to receive(:connection).and_return(connection_failed_class.new) expect do subject.shorten_parameters(parameters) end.to raise_error(FirebaseDynamicLink::ConnectionError) end - it 'raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised' do + it "raise FirebaseDynamicLink::ConnectionError if Faraday::TimeoutError raised" do allow_any_instance_of(described_class).to receive(:connection).and_return(timout_error_class.new) expect do subject.shorten_parameters(parameters) diff --git a/spec/connection_spec.rb b/spec/connection_spec.rb index 16ac13f..4af4a4f 100644 --- a/spec/connection_spec.rb +++ b/spec/connection_spec.rb @@ -1,27 +1,28 @@ +# typed: false # frozen_string_literal: true RSpec.describe FirebaseDynamicLink::Connection do subject { instance } - let(:instance) { described_class.new('http://saiqulhaq.com') } + let(:instance) { described_class.new("http://saiqulhaq.com") } - describe '#timeout' do - it 'uses default config timeout as default' do + describe "#timeout" do + it "uses default config timeout as default" do expect(instance.timeout).to eq(FirebaseDynamicLink.config.timeout) end - it 'configurable' do + it "configurable" do instance.timeout = 10 expect(instance.timeout).to eq(10) end end - describe '#open_timeout' do - it 'uses default config open_timeout as default' do + describe "#open_timeout" do + it "uses default config open_timeout as default" do expect(instance.open_timeout).to eq(FirebaseDynamicLink.config.open_timeout) end - it 'configurable' do + it "configurable" do instance.open_timeout = 8 expect(instance.open_timeout).to eq(8) end diff --git a/spec/firebase_dynamic_link_spec.rb b/spec/firebase_dynamic_link_spec.rb index 4ed6145..090a6fa 100644 --- a/spec/firebase_dynamic_link_spec.rb +++ b/spec/firebase_dynamic_link_spec.rb @@ -1,15 +1,16 @@ +# typed: false # frozen_string_literal: true -require 'faraday' +require "faraday" RSpec.describe FirebaseDynamicLink do before(:all) { described_class.reset_config } - it 'has a version number' do - expect(FirebaseDynamicLink::VERSION).to eq('2.0.1') + it "has a version number" do + expect(FirebaseDynamicLink::VERSION).to eq("2.0.1") end - describe '.config' do + describe ".config" do subject { described_class.config } { @@ -19,11 +20,11 @@ }, api_key: { default: nil, - valid_value: 'foobar' + valid_value: "foobar" }, dynamic_link_domain: { default: nil, - valid_value: 'http://asd.com/asd' + valid_value: "http://asd.com/asd" }, timeout: { default: 3, @@ -34,12 +35,12 @@ valid_value: 1 }, suffix_option: { - default: 'UNGUESSABLE', - valid_value: 'SHORT' + default: "UNGUESSABLE", + valid_value: "SHORT" } }.each do |method, meta| describe ".#{method}" do - it "default value is #{meta[:default].nil? ? 'nil' : meta[:default]}" do + it "default value is #{meta[:default].nil? ? "nil" : meta[:default]}" do if subject.respond_to? :values expect(subject.values[method]).to eq(meta[:default]) else @@ -47,7 +48,7 @@ end end - it 'is writable' do + it "is writable" do subject.send("#{method}=".to_sym, meta[:valid_value]) if subject.respond_to? :values expect(subject.values[method]).to eq(meta[:valid_value]) @@ -58,9 +59,9 @@ end end - describe 'suffix_option=' do - it 'raises FirebaseDynamicLink::InvalidConfig if given parameter is not valid' do - expect { subject.suffix_option = 'FOO' }.to raise_error(FirebaseDynamicLink::InvalidConfig) + describe "suffix_option=" do + it "raises FirebaseDynamicLink::InvalidConfig if given parameter is not valid" do + expect { subject.suffix_option = "FOO" }.to raise_error(FirebaseDynamicLink::InvalidConfig) end end end diff --git a/spec/link_renderer_spec.rb b/spec/link_renderer_spec.rb index 77eeb94..8b299ca 100644 --- a/spec/link_renderer_spec.rb +++ b/spec/link_renderer_spec.rb @@ -1,13 +1,14 @@ +# typed: false # frozen_string_literal: true RSpec.describe FirebaseDynamicLink::LinkRenderer do let(:success_response) do OpenStruct.new(status: 200, body: { - shortLink: 'http://link', - previewLink: 'http://xxx.goo.gl/foo?preview', + shortLink: "http://link", + previewLink: "http://xxx.goo.gl/foo?preview", warning: [{ - 'warningCode' => 'UNRECOGNIZED_PARAM', - 'warningMessage' => '...' + "warningCode" => "UNRECOGNIZED_PARAM", + "warningMessage" => "..." }] }.to_json) end @@ -15,48 +16,48 @@ let(:fail_response) do OpenStruct.new(status: [422, 500].sample, body: { error: { - message: 'xxx' + message: "xxx" } }.to_json) end let(:instance) { described_class.new } - describe '#render' do - context 'when response is success' do - it 'parsed output correctly' do + describe "#render" do + context "when response is success" do + it "parsed output correctly" do output = instance.render(success_response) expect(output).to have_key(:link) expect(output).to have_key(:preview_link) expect(output).to have_key(:warning) - expect(output[:link]).to eq('http://link') + expect(output[:link]).to eq("http://link") end - it 'raise error if response body has error key' do - success_response.body = JSON.parse(success_response.body).merge(error: 'foo').to_json + it "raise error if response body has error key" do + success_response.body = JSON.parse(success_response.body).merge(error: "foo").to_json expect do instance.render(success_response) end.to raise_error(FirebaseDynamicLink::ConnectionError) end end - context 'when response is fail' do - it 'raises error' do + context "when response is fail" do + it "raises error" do expect do instance.render(fail_response) end.to raise_error(FirebaseDynamicLink::ConnectionError) end - it 'render response.body if response.body.error.message is not exist' do - fail_response.body = 'foobar' + it "render response.body if response.body.error.message is not exist" do + fail_response.body = "foobar" expect do instance.render(fail_response) end.to raise_error(FirebaseDynamicLink::ConnectionError) end end - context 'when response.status is 429' do - it 'raise FirebaseDynamicLink::QuotaExceeded' do + context "when response.status is 429" do + it "raise FirebaseDynamicLink::QuotaExceeded" do response = fail_response response.status = 429 expect do diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index 812dbf4..8f856cc 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,35 +1,36 @@ +# typed: false # frozen_string_literal: true -require 'bundler/setup' -require 'bootsnap' -require 'faraday' +require "bundler/setup" +require "bootsnap" +require "faraday" -enable_coverage = ENV.fetch('COVERAGE', 0).to_s == '1' +enable_coverage = ENV.fetch("COVERAGE", 0).to_s == "1" Bootsnap.setup( - cache_dir: 'tmp/cache', # Path to your cache + cache_dir: "tmp/cache", # Path to your cache development_mode: true, # Current working environment, e.g. RACK_ENV, RAILS_ENV, etc load_path_cache: true, # Optimize the LOAD_PATH with a cache compile_cache_iseq: !enable_coverage, # Compile Ruby code into ISeq cache, breaks coverage reporting. compile_cache_yaml: true # Compile YAML into a cache ) -require 'dotenv/load' +require "dotenv/load" if enable_coverage - require 'simplecov' + require "simplecov" SimpleCov.start end -require 'firebase_dynamic_link' -require 'vcr' +require "firebase_dynamic_link" +require "vcr" begin - require 'pry' + require "pry" rescue LoadError end -require 'dry/configurable/test_interface' +require "dry/configurable/test_interface" begin module FirebaseDynamicLink @@ -43,7 +44,7 @@ module FirebaseDynamicLink RSpec.configure do |config| # Enable flags like --only-failures and --next-failure - config.example_status_persistence_file_path = '.rspec_status' + config.example_status_persistence_file_path = ".rspec_status" # Disable RSpec exposing methods globally on `Module` and `main` config.disable_monkey_patching! @@ -52,13 +53,13 @@ module FirebaseDynamicLink c.syntax = :expect end - config.after(:each) do + config.after do Faraday.default_connection = nil end end VCR.configure do |config| config.allow_http_connections_when_no_cassette = true - config.cassette_library_dir = 'spec/fixtures/vcr_cassettes' + config.cassette_library_dir = "spec/fixtures/vcr_cassettes" config.hook_into :faraday end