├── sorbet ├── config └── rbi │ ├── gems │ ├── jaro_winkler.rbi │ ├── unicode-display_width.rbi │ ├── ast.rbi │ ├── parallel.rbi │ ├── rainbow.rbi │ ├── ruby-progressbar.rbi │ ├── minitest.rbi │ └── parser.rbi │ ├── todo.rbi │ └── sorbet-typed │ └── lib │ ├── minitest │ └── all │ │ └── minitest.rbi │ ├── ruby │ └── all │ │ ├── open3.rbi │ │ └── resolv.rbi │ └── rainbow │ └── all │ └── rainbow.rbi ├── test ├── test_helper.rb ├── fixtures │ ├── 01_bar_chart.dump │ ├── 01_verbose.txt │ └── 01.json ├── sorbet_progress │ ├── version_test.rb │ ├── cli_test.rb │ └── reporters │ │ ├── verbose_test.rb │ │ └── bar_chart_test.rb └── all.rb ├── bin ├── sorbet_progress ├── test.sh └── console ├── lib ├── sorbet_progress │ ├── version.rb │ ├── metric.rb │ ├── reporters │ │ ├── base.rb │ │ ├── verbose.rb │ │ └── bar_chart.rb │ ├── error.rb │ ├── metrics.rb │ ├── parser.rb │ ├── cli.rb │ └── calculator.rb └── sorbet_progress.rb ├── .travis.yml ├── .gitignore ├── Gemfile ├── Rakefile ├── sorbet-progress.gemspec ├── CHANGELOG.md ├── README.md ├── CODE_OF_CONDUCT.md └── .rubocop.yml /sorbet/config: -------------------------------------------------------------------------------- 1 | --ignore=/vendor 2 | --dir 3 | . 4 | -------------------------------------------------------------------------------- /test/test_helper.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | # typed: strict 4 | $LOAD_PATH.unshift File.expand_path("../lib", __dir__) 5 | require "sorbet_progress" 6 | -------------------------------------------------------------------------------- /bin/sorbet_progress: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | # frozen_string_literal: true 3 | # typed: ignore 4 | 5 | require 'sorbet_progress' 6 | SorbetProgress::CLI.new(ARGV).run 7 | -------------------------------------------------------------------------------- /lib/sorbet_progress/version.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | # :nodoc: 5 | module SorbetProgress 6 | def self.gem_version 7 | Gem::Version.new("0.3.0") 8 | end 9 | end 10 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | --- 2 | before_install: gem install bundler -v 2.1.3 3 | cache: bundler 4 | env: 5 | - TRAVIS=true 6 | language: ruby 7 | rvm: 8 | - 2.6.5 9 | - 2.7.0 10 | script: bin/test.sh 11 | sudo: false 12 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .ruby-version 2 | /.bundle/ 3 | /.yardoc 4 | /_yardoc/ 5 | /coverage/ 6 | /doc/ 7 | /pkg/ 8 | /spec/reports/ 9 | /tmp/ 10 | /*.gem 11 | /Gemfile.lock 12 | /.idea 13 | sorbet/rbi/hidden-definitions/errors.txt 14 | -------------------------------------------------------------------------------- /Gemfile: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | source "https://rubygems.org" 4 | 5 | git_source(:github) { |repo_name| "https://github.com/#{repo_name}" } 6 | 7 | # Specify your gem's dependencies in sorbet-progress.gemspec 8 | gemspec 9 | -------------------------------------------------------------------------------- /lib/sorbet_progress.rb: -------------------------------------------------------------------------------- 1 | # typed: strong 2 | # frozen_string_literal: true 3 | 4 | require "sorbet-runtime" 5 | require "sorbet_progress/cli" 6 | require "sorbet_progress/version" 7 | 8 | # :nodoc: 9 | module SorbetProgress 10 | end 11 | -------------------------------------------------------------------------------- /test/fixtures/01_bar_chart.dump: -------------------------------------------------------------------------------- 1 | "Sorbet progress: ignore | false | true | strict+\n|\e[31m-0-\e[0m|\e[33m----10----\e[0m|\e[32m----------------40----------------\e[0m|\e[34m----------------40----------------\e[0m|\nKeep up the good work \u{1F44D}" 2 | -------------------------------------------------------------------------------- /bin/test.sh: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env bash 2 | 3 | set -e 4 | 5 | bundle exec srb tc --metrics-file /tmp/sorbet_metrics.json 6 | bundle exec bin/sorbet_progress --reporter bar_chart /tmp/sorbet_metrics.json 7 | bundle exec rubocop 8 | bundle exec ruby -I lib:test test/all.rb 9 | -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | require "bundler/gem_tasks" 4 | require "rake/testtask" 5 | 6 | Rake::TestTask.new(:test) do |t| 7 | t.libs << "test" 8 | t.libs << "lib" 9 | t.test_files = FileList["test/**/*_test.rb"] 10 | end 11 | 12 | task default: :test 13 | -------------------------------------------------------------------------------- /test/sorbet_progress/version_test.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | require "test_helper" 5 | 6 | module SorbetProgress 7 | class VersionTest < Minitest::Test 8 | def test_that_it_has_a_version_number 9 | assert ::SorbetProgress.gem_version.is_a?(::Gem::Version) 10 | end 11 | end 12 | end 13 | -------------------------------------------------------------------------------- /test/sorbet_progress/cli_test.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | require "test_helper" 5 | 6 | module SorbetProgress 7 | class CLITest < Minitest::Test 8 | def test_run 9 | path = File.expand_path("../fixtures/01.json", __dir__) 10 | cli = CLI.new([path]) 11 | assert_output(/Sorbet Progress/) { cli.run } 12 | end 13 | end 14 | end 15 | -------------------------------------------------------------------------------- /bin/console: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "bundler/setup" 4 | require "sorbet_progress" 5 | 6 | # You can add fixtures and/or initialization code here to make experimenting 7 | # with your gem easier. You can also use a different console, if you like. 8 | 9 | # (If you use this, don't forget to add pry to your Gemfile!) 10 | # require "pry" 11 | # Pry.start 12 | 13 | require "irb" 14 | IRB.start(__FILE__) 15 | -------------------------------------------------------------------------------- /test/fixtures/01_verbose.txt: -------------------------------------------------------------------------------- 1 | Sorbet Progress 2 | 3 | Progress for sig coverage 4 | total_signatures 1552 5 | total_methods 5245 6 | total_classes 3779 7 | 8 | Progress for file coverage 9 | sigil_ignore 0 0.00 % 10 | sigil_false 1 10.00 % 11 | sigil_true 4 40.00 % 12 | sigil_strict 1 10.00 % 13 | sigil_strong 3 30.00 % 14 | --------------------------------------- 15 | Total: 10 100% 16 | Keep up the good work 👍 17 | -------------------------------------------------------------------------------- /lib/sorbet_progress/metric.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | module SorbetProgress 5 | # Just a simple key-value pair, though sorbet could decide to do something 6 | # more complicated in the future. 7 | class Metric 8 | extend T::Sig 9 | 10 | attr_reader :name, :value 11 | 12 | sig { params(name: String, value: Integer).void } 13 | def initialize(name, value) 14 | @name = name 15 | @value = value 16 | end 17 | end 18 | end 19 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/jaro_winkler.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/jaro_winkler/all/jaro_winkler.rbi 9 | # 10 | # jaro_winkler-1.5.4 11 | module JaroWinkler 12 | def self.distance(*arg0); end 13 | def self.jaro_distance(*arg0); end 14 | end 15 | -------------------------------------------------------------------------------- /lib/sorbet_progress/reporters/base.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | # frozen_string_literal: true 3 | 4 | require "rainbow" 5 | 6 | module SorbetProgress 7 | module Reporters 8 | # Abstract 9 | class Base 10 | extend T::Helpers 11 | extend T::Sig 12 | abstract! 13 | 14 | sig { params(calculator: Calculator).void } 15 | def initialize(calculator) 16 | @calculator = calculator 17 | end 18 | 19 | sig { abstract.returns(String) } 20 | def report 21 | end 22 | end 23 | end 24 | end 25 | -------------------------------------------------------------------------------- /lib/sorbet_progress/error.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | # frozen_string_literal: true 3 | 4 | module SorbetProgress 5 | # Parent class of all errors raised by SorbetProgress. 6 | # Every error should have a unique number. 7 | class Error < StandardError 8 | extend T::Sig 9 | 10 | sig { params(number: Integer, message: String).void } 11 | def initialize(number, message) 12 | super( 13 | format( 14 | "%s (SPE%d)", 15 | message, 16 | number 17 | ) 18 | ) 19 | end 20 | end 21 | end 22 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/unicode-display_width.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/unicode-display_width/all/unicode-display_width.rbi 9 | # 10 | # unicode-display_width-1.6.0 11 | module Unicode 12 | end 13 | module Unicode::DisplayWidth 14 | def self.emoji_extra_width_of(string, ambiguous = nil, overwrite = nil, _ = nil); end 15 | def self.of(string, ambiguous = nil, overwrite = nil, options = nil); end 16 | end 17 | -------------------------------------------------------------------------------- /test/sorbet_progress/reporters/verbose_test.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | require "test_helper" 5 | 6 | module SorbetProgress 7 | module Reporters 8 | class VerboseTest < Minitest::Test 9 | def test_report_01 10 | path = File.expand_path("../../fixtures/01.json", __dir__) 11 | metrics = Parser.new.parse(File.read(path)) 12 | calc = Calculator.new(metrics) 13 | reporter = Verbose.new(calc) 14 | expected_output_path = File.expand_path( 15 | "../../fixtures/01_verbose.txt", 16 | __dir__ 17 | ) 18 | expected_output = File.read(expected_output_path) 19 | assert_equal(expected_output.strip, reporter.report) 20 | end 21 | end 22 | end 23 | end 24 | -------------------------------------------------------------------------------- /sorbet/rbi/todo.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi todo 3 | 4 | # typed: strong 5 | module T::Private::Methods::MethodHooks; end 6 | module T::Private::Methods::MethodHooks; end 7 | module T::Private::Methods::MethodHooks; end 8 | module T::Private::Methods::MethodHooks; end 9 | module T::Private::Methods::MethodHooks; end 10 | module T::Private::Methods::MethodHooks; end 11 | module T::Private::Methods::MethodHooks; end 12 | module T::Private::Methods::SingletonMethodHooks; end 13 | module T::Private::Methods::SingletonMethodHooks; end 14 | module T::Private::Methods::SingletonMethodHooks; end 15 | module T::Private::Methods::SingletonMethodHooks; end 16 | module T::Private::Methods::SingletonMethodHooks; end 17 | module T::Private::Methods::SingletonMethodHooks; end 18 | module T::Private::Methods::SingletonMethodHooks; end 19 | -------------------------------------------------------------------------------- /test/all.rb: -------------------------------------------------------------------------------- 1 | # typed: strong 2 | # frozen_string_literal: true 3 | 4 | require "minitest" 5 | require "sorbet-runtime" 6 | 7 | module SorbetProgress 8 | # A simple replacement for Rake::TestTask. Assumes that the `test` directory 9 | # is already on the LOAD_PATH via the `ruby -I` in bin/test.sh 10 | class TestTask 11 | extend T::Sig 12 | 13 | sig { void } 14 | def run 15 | Dir.glob("test/**/*_test.rb").each do |path| 16 | require drop_first_path_segment(path) 17 | end 18 | Minitest.run 19 | end 20 | 21 | private 22 | 23 | sig { params(path: String).returns(String) } 24 | def drop_first_path_segment(path) 25 | path.split(File::SEPARATOR).drop(1).join(File::SEPARATOR) 26 | end 27 | end 28 | end 29 | 30 | # Prevent eg. `srb init` from accidentally running tests. 31 | if __FILE__ == $PROGRAM_NAME 32 | SorbetProgress::TestTask.new.run 33 | end 34 | -------------------------------------------------------------------------------- /lib/sorbet_progress/metrics.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | # frozen_string_literal: true 3 | 4 | require "sorbet_progress/error" 5 | require "sorbet_progress/metric" 6 | 7 | module SorbetProgress 8 | # A collection of `Metric`s. Acts like a Hash, though sorbet actually gives 9 | # us an array. 10 | class Metrics 11 | extend T::Sig 12 | 13 | sig { params(array: T::Array[Metric]).void } 14 | def initialize(array) 15 | @array = array 16 | end 17 | 18 | sig { params(name: String).returns(T.nilable(Metric)) } 19 | def [](name) 20 | @array.find { |metric| metric.name == name } 21 | end 22 | 23 | sig { params(name: String).returns(Metric) } 24 | def fetch(name) 25 | result = @array.find { |metric| metric.name == name } 26 | if result.nil? 27 | raise Error.new(5, "Metric not found: " + name) 28 | else 29 | result 30 | end 31 | end 32 | end 33 | end 34 | -------------------------------------------------------------------------------- /test/sorbet_progress/reporters/bar_chart_test.rb: -------------------------------------------------------------------------------- 1 | # typed: true 2 | # frozen_string_literal: true 3 | 4 | require "test_helper" 5 | require "sorbet_progress/reporters/bar_chart" 6 | 7 | module SorbetProgress 8 | module Reporters 9 | class BarChartTest < Minitest::Test 10 | def test_report_01 11 | path = File.expand_path("../../fixtures/01.json", __dir__) 12 | metrics = Parser.new.parse(File.read(path)) 13 | calc = Calculator.new(metrics) 14 | reporter = BarChart.new(calc) 15 | 16 | # The fixture file is in "dump" format, á la `String.dump`. It's the 17 | # only format I could think that would allow me to have a fixture file. 18 | expected_output_path = File.expand_path( 19 | "../../fixtures/01_bar_chart.dump", 20 | __dir__ 21 | ) 22 | expected_output = File.read(expected_output_path) 23 | assert_equal(expected_output.strip, reporter.report.dump) 24 | end 25 | end 26 | end 27 | end 28 | -------------------------------------------------------------------------------- /lib/sorbet_progress/parser.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | # typed: true 4 | 5 | require "json" 6 | require "sorbet_progress/error" 7 | require "sorbet_progress/metric" 8 | require "sorbet_progress/metrics" 9 | 10 | module SorbetProgress 11 | # Parse Sorbet's JSON metrics file. 12 | class Parser 13 | extend T::Sig 14 | 15 | sig { params(json: String).returns(Metrics) } 16 | def parse(json) 17 | transform(parse_json(json)) 18 | end 19 | 20 | private 21 | 22 | sig { params(json: String).returns(Hash) } 23 | def parse_json(json) 24 | JSON.parse(json) 25 | rescue JSON::ParserError => e 26 | raise Error.new(3, "Metrics file is not valid JSON: " + e.message) 27 | end 28 | 29 | sig { params(parsed: Hash).returns(Metrics) } 30 | def transform(parsed) 31 | Metrics.new( 32 | parsed. 33 | fetch("metrics"). 34 | map { |metric| 35 | next unless metric.key?("value") 36 | Metric.new( 37 | metric.fetch("name"), 38 | metric.fetch("value") 39 | ) 40 | }. 41 | compact 42 | ) 43 | rescue KeyError => e 44 | raise Error.new(4, "Expected file to have key: metrics: " + e.message) 45 | end 46 | end 47 | end 48 | -------------------------------------------------------------------------------- /sorbet-progress.gemspec: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | lib = File.expand_path("lib", __dir__) 4 | $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) 5 | require "sorbet_progress/version" 6 | 7 | Gem::Specification.new do |spec| 8 | spec.name = "sorbet-progress" 9 | spec.version = SorbetProgress.gem_version.to_s 10 | spec.licenses = ["AGPL-3.0-only"] 11 | spec.authors = ["Jared Beck"] 12 | spec.email = ["jared@jaredbeck.com"] 13 | spec.summary = "Measure sorbet adoption progress" 14 | spec.homepage = "https://github.com/jaredbeck/sorbet-progress" 15 | spec.files = Dir.chdir(File.expand_path(__dir__)) do 16 | `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^test/}) } 17 | end 18 | spec.bindir = "bin" 19 | spec.executables = ["sorbet_progress"] 20 | spec.require_paths = ["lib"] 21 | spec.required_ruby_version = ">= 2.6.3" 22 | spec.required_rubygems_version = ">= 3.0.3" 23 | 24 | spec.add_runtime_dependency "rainbow", "3.0" 25 | lambda { 26 | requirements = ">= 0.4.4314" 27 | spec.add_runtime_dependency "sorbet", requirements 28 | spec.add_runtime_dependency "sorbet-runtime", requirements 29 | }.call 30 | 31 | spec.add_development_dependency "bundler", "~> 2.1" 32 | spec.add_development_dependency "minitest", "~> 5.0" 33 | spec.add_development_dependency "rubocop", "~> 0.72.0" 34 | end 35 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/ast.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ast/all/ast.rbi 9 | # 10 | # ast-2.4.0 11 | module AST 12 | end 13 | class AST::Node 14 | def +(array); end 15 | def <<(element); end 16 | def ==(other); end 17 | def append(element); end 18 | def assign_properties(properties); end 19 | def children; end 20 | def clone; end 21 | def concat(array); end 22 | def dup; end 23 | def eql?(other); end 24 | def fancy_type; end 25 | def hash; end 26 | def initialize(type, children = nil, properties = nil); end 27 | def inspect(indent = nil); end 28 | def original_dup; end 29 | def to_a; end 30 | def to_ast; end 31 | def to_s(indent = nil); end 32 | def to_sexp(indent = nil); end 33 | def to_sexp_array; end 34 | def type; end 35 | def updated(type = nil, children = nil, properties = nil); end 36 | end 37 | class AST::Processor 38 | include AST::Processor::Mixin 39 | end 40 | module AST::Processor::Mixin 41 | def handler_missing(node); end 42 | def process(node); end 43 | def process_all(nodes); end 44 | end 45 | module AST::Sexp 46 | def s(type, *children); end 47 | end 48 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | # Changelog 2 | 3 | This project follows [semver 2.0.0](http://semver.org/spec/v2.0.0.html) and the 4 | recommendations of [keepachangelog.com](http://keepachangelog.com/). 5 | 6 | ## Unreleased 7 | 8 | - Breaking Changes 9 | - None 10 | - Added 11 | - None 12 | - Fixed 13 | - None 14 | 15 | ## 0.3.0 (2020-01-24) 16 | 17 | - Breaking Changes 18 | - None 19 | - Added 20 | - `--reporter` CLI option 21 | - `bar_chart` reporter 22 | - Fixed 23 | - None 24 | 25 | ## 0.2.5 (2020-01-03) 26 | 27 | - Breaking Changes 28 | - None 29 | - Added 30 | - Support for sorbet 0.5 31 | - Fixed 32 | - None 33 | 34 | ## 0.2.4 (2019-10-11) 35 | 36 | - Breaking Changes 37 | - None 38 | - Added 39 | - [#1](https://github.com/jaredbeck/sorbet-progress/pull/1) - sigil percentages 40 | - Fixed 41 | - None 42 | 43 | ## 0.2.3 (2019-07-08) 44 | 45 | - Breaking Changes 46 | - None 47 | - Added 48 | - None 49 | - Fixed 50 | - Measure the `typed: strict` sigil 51 | - Dependencies 52 | - Relax sorbet constraint to `< 0.5` 53 | 54 | ## 0.2.2 (2019-07-02) 55 | 56 | - Breaking Changes 57 | - None 58 | - Added 59 | - None 60 | - Fixed 61 | - Fix executables in gemspec 62 | 63 | ## 0.2.1 (2019-07-02) 64 | 65 | - Breaking Changes 66 | - None 67 | - Added 68 | - Supports sorbet 0.4.4314 69 | - Fixed 70 | - None 71 | 72 | ## 0.2.0 (2019-07-02) 73 | 74 | First working proof of concept. 75 | -------------------------------------------------------------------------------- /lib/sorbet_progress/cli.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | # typed: true 4 | 5 | require "sorbet_progress/calculator" 6 | require "sorbet_progress/error" 7 | require "sorbet_progress/metrics" 8 | require "sorbet_progress/parser" 9 | require "sorbet_progress/reporters/bar_chart" 10 | require "sorbet_progress/reporters/base" 11 | require "sorbet_progress/reporters/verbose" 12 | 13 | module SorbetProgress 14 | # Parses the provided metrics file and prints a report. 15 | class CLI 16 | extend T::Sig 17 | 18 | USAGE = <<~EOS 19 | Usage: sorbet_progress [--reporter name] /path/to/sorbet_metrics.json 20 | Reporters: bar_chart, verbose 21 | EOS 22 | 23 | sig { params(argv: T::Array[String]).void } 24 | def initialize(argv) 25 | # TODO: use an actual CLI args parser, like optparse or trollop 26 | case argv.length 27 | when 1 28 | @path = argv.first 29 | @reporter_name = "verbose" 30 | when 3 31 | @path = argv.last 32 | @reporter_name = argv[1] 33 | else 34 | raise Error.new(1, USAGE) 35 | end 36 | end 37 | 38 | sig { void } 39 | def run 40 | metrics = parse(@path) 41 | calculator = Calculator.new(metrics) 42 | reporter = reporter_class(@reporter_name).new(calculator) 43 | puts reporter.report 44 | end 45 | 46 | private 47 | 48 | sig { params(path: String).returns(Metrics) } 49 | def parse(path) 50 | Parser.new.parse(File.read(path)) 51 | rescue Errno::ENOENT => e 52 | raise Error.new(2, "Metrics file not found: " + e.message) 53 | end 54 | 55 | sig { params(name: String).returns(T.class_of(Reporters::Base)) } 56 | def reporter_class(name) 57 | case name 58 | when "verbose" 59 | Reporters::Verbose 60 | when "bar_chart" 61 | Reporters::BarChart 62 | else 63 | raise format("Invalid reporter name: %s", @reporter_name) 64 | end 65 | end 66 | end 67 | end 68 | -------------------------------------------------------------------------------- /lib/sorbet_progress/calculator.rb: -------------------------------------------------------------------------------- 1 | # frozen_string_literal: true 2 | 3 | # typed: true 4 | 5 | module SorbetProgress 6 | # Computes the percentage stats for sigil metrics as well as other stats. 7 | class Calculator 8 | extend T::Sig 9 | 10 | attr_reader :total, :sigil_percentages, :coverage_metrics 11 | 12 | sig { params(metrics: Metrics).void } 13 | def initialize(metrics) 14 | values = collect_values(sigil_breakdown_stats, metrics) 15 | @total = values.delete(:total_files) 16 | 17 | @sigil_percentages = values.map do |label, value| 18 | percentage = value * 1.0 / @total if @total && value 19 | { 20 | label: label, 21 | value: value, 22 | percentage: percentage 23 | } 24 | end 25 | 26 | @coverage_metrics = collect_values(coverage_stats, metrics) 27 | end 28 | 29 | private 30 | 31 | # Mapping of general coverage stats to their actual metric names. 32 | sig { returns(T::Hash[Symbol, String]) } 33 | def coverage_stats 34 | { 35 | total_signatures: "ruby_typer.unknown..types.sig.count", 36 | total_methods: "ruby_typer.unknown..types.input.methods.total", 37 | total_classes: "ruby_typer.unknown..types.input.classes.total" 38 | } 39 | end 40 | 41 | # Mapping of sigil stats to their actual metric names. 42 | sig { returns(T::Hash[Symbol, String]) } 43 | def sigil_breakdown_stats 44 | { 45 | total_files: "ruby_typer.unknown..types.input.files", 46 | sigil_ignore: "ruby_typer.unknown..types.input.files.sigil.ignore", 47 | sigil_false: "ruby_typer.unknown..types.input.files.sigil.false", 48 | sigil_true: "ruby_typer.unknown..types.input.files.sigil.true", 49 | sigil_strict: "ruby_typer.unknown..types.input.files.sigil.strict", 50 | sigil_strong: "ruby_typer.unknown..types.input.files.sigil.strong" 51 | } 52 | end 53 | 54 | # Extract the requested metric values. 55 | sig { 56 | params( 57 | requested_stats: T::Hash[Symbol, String], 58 | metrics: Metrics 59 | ).returns(T::Hash[Symbol, T.nilable(Integer)]) 60 | } 61 | def collect_values(requested_stats, metrics) 62 | result = {} 63 | requested_stats.map do |label, name| 64 | result[label] = metrics[name]&.value 65 | end 66 | result 67 | end 68 | end 69 | end 70 | -------------------------------------------------------------------------------- /lib/sorbet_progress/reporters/verbose.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | # frozen_string_literal: true 3 | 4 | require "sorbet_progress/reporters/base" 5 | 6 | module SorbetProgress 7 | module Reporters 8 | # The first reporter written. It's quite verbose, so I'm calling it .. 9 | class Verbose < Base 10 | extend T::Sig 11 | 12 | sig { params(calculator: Calculator).void } 13 | def initialize(calculator) 14 | @calculator = calculator 15 | end 16 | 17 | sig { override.returns(String) } 18 | def report 19 | [ 20 | "Sorbet Progress\n", 21 | "Progress for sig coverage", 22 | coverage_metrics, 23 | "\nProgress for file coverage", 24 | sigil_percentages, 25 | "---------------------------------------", 26 | "Total: \t\t\t#{@calculator.total}\t100%", 27 | "Keep up the good work 👍" 28 | ].flatten.join("\n") 29 | end 30 | 31 | private 32 | 33 | # Example output: 34 | # 35 | # ``` 36 | # total_signatures 7528 37 | # total_methods 183447 38 | # total_classes 112433 39 | # ``` 40 | sig { returns(T::Array[String]) } 41 | def coverage_metrics 42 | @calculator.coverage_metrics.map do |label, value| 43 | format_metric(label, value) 44 | end 45 | end 46 | 47 | # Format a label and metric value into a presentable String. 48 | sig { params(label: Symbol, value: Integer).returns(String) } 49 | def format_metric(label, value) 50 | if value.nil? 51 | format("%-17s\tunknown", label) 52 | else 53 | format("%-17s\t%d", label, value) 54 | end 55 | end 56 | 57 | # Example output: 58 | # 59 | # ``` 60 | # sigil_ignore 12 0.20 % 61 | # sigil_false 5466 91.60 % 62 | # sigil_true 460 7.71 % 63 | # sigil_strict 12 0.20 % 64 | # sigil_strong 17 0.28 % 65 | # ``` 66 | sig { returns(T::Array[String]) } 67 | def sigil_percentages 68 | @calculator.sigil_percentages.map do |elem| 69 | percentage = 70 | if elem[:percentage] 71 | elem[:percentage] * 100 72 | else 73 | 0 74 | end 75 | format( 76 | "%-17s\t%d\t%.2f %%", 77 | elem[:label], 78 | elem[:value] || 0, 79 | percentage 80 | ) 81 | end 82 | end 83 | end 84 | end 85 | end 86 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # SorbetProgress 2 | 3 | Measure your progress as you adopt [sorbet](https://sorbet.org/). I find that 4 | measuring progress keeps me motivated, which is crucial to finishing a project. 5 | 6 | ## Installation 7 | 8 | Add this line to your application's Gemfile: 9 | 10 | ```ruby 11 | gem 'sorbet-progress' 12 | ``` 13 | 14 | Then: 15 | 16 | bundle 17 | 18 | Or install it yourself: 19 | 20 | gem install sorbet-progress 21 | 22 | ## Usage 23 | 24 | ```bash 25 | bundle exec srb tc --metrics-file /tmp/sorbet_metrics.json 26 | # No errors! Great job. 27 | bundle exec sorbet_progress /tmp/sorbet_metrics.json 28 | # Sorbet Progress 29 | 30 | # Progress for sig coverage 31 | # total_signatures 7528 32 | # total_methods 183447 33 | # total_classes 112433 34 | 35 | # Progress for file coverage 36 | # sigil_ignore 12 0.20 % 37 | # sigil_false 5466 91.60 % 38 | # sigil_true 460 7.71 % 39 | # sigil_strict 12 0.20 % 40 | # sigil_strong 17 0.28 % 41 | # --------------------------------------- 42 | # Total: 5967 100% 43 | # Keep up the good work 👍 44 | ``` 45 | 46 | Not sure what the best format is. Pull requests welcome. It might be nice to 47 | have an overall percentage, for example. 48 | 49 | ## Reporters 50 | 51 | ### bar_chart 52 | 53 | ``` 54 | bundle exec sorbet_progress --reporter bar_chart /tmp/sorbet_metrics.json 55 | Sorbet progress: ignore | false | true | strict+ 56 | |-0-|-2-|-------------32-------------|-------------------------61-------------------------| 57 | Keep up the good work 👍 58 | ``` 59 | 60 | The chart sums `strict` and `strong`, because `strict` is the highest reasonable 61 | goal for most applications. 62 | 63 | ### verbose 64 | 65 | ``` 66 | bundle exec sorbet_progress --verbose /tmp/sorbet_metrics.json 67 | Sorbet Progress 68 | 69 | Progress for sig coverage 70 | total_signatures 7528 71 | total_methods 183447 72 | total_classes 112433 73 | 74 | Progress for file coverage 75 | sigil_ignore 12 0.20 % 76 | sigil_false 5466 91.60 % 77 | sigil_true 460 7.71 % 78 | sigil_strict 12 0.20 % 79 | sigil_strong 17 0.28 % 80 | --------------------------------------- 81 | Total: 5967 100% 82 | Keep up the good work 👍 83 | ``` 84 | 85 | See example 86 | 87 | ## Contributing 88 | 89 | This project does not accept bug reports. Pull requests are welcome. 90 | 91 | This project is intended to be a safe, welcoming space for collaboration, and 92 | contributors are expected to adhere to the [code of conduct](/CODE_OF_CONDUCT.md) 93 | -------------------------------------------------------------------------------- /lib/sorbet_progress/reporters/bar_chart.rb: -------------------------------------------------------------------------------- 1 | # typed: strict 2 | # frozen_string_literal: true 3 | 4 | require "rainbow" 5 | require "sorbet_progress/reporters/base" 6 | 7 | module SorbetProgress 8 | module Reporters 9 | # Produces output something like this: 10 | # 11 | # ``` 12 | # Sorbet progress: ignore | false | true | strict+ 13 | # |----------------50--------------|---------25--------|-5-|------20------| 14 | # Keep up the good work 👍 15 | # ``` 16 | # 17 | # The chart is colored. Colorless terminals are not supported. 18 | # 19 | # Strict and strong are combined into one category because strong is not 20 | # a reachable goal in most projects. 21 | class BarChart < Base 22 | extend T::Sig 23 | 24 | COLORS = T.let(%w[red yellow green blue].freeze, T::Array[String]) 25 | LENGTH = 80 26 | 27 | sig { params(calculator: Calculator).void } 28 | def initialize(calculator) 29 | @calculator = calculator 30 | end 31 | 32 | sig { override.returns(String) } 33 | def report 34 | [ 35 | "Sorbet progress: ignore | false | true | strict+", 36 | bar_chart, 37 | "Keep up the good work 👍" 38 | ].flatten.join("\n") 39 | end 40 | 41 | private 42 | 43 | sig { returns(String) } 44 | def bar_chart 45 | body = segments.each_with_index.each_with_object([]) { |(e, i), a| 46 | a.push(segment(e, i)) 47 | }.join("|") 48 | format("|%s|", body) 49 | end 50 | 51 | sig { params(fraction: Float, index: Integer).returns(String) } 52 | def segment(fraction, index) 53 | padding_max = (fraction * LENGTH / 2).round 54 | padding_length = [1, padding_max].max 55 | pad = "-" * padding_length 56 | Rainbow( 57 | format("%s%d%s", pad, fraction * 100, pad) 58 | ).send(T.must(COLORS[index])) 59 | end 60 | 61 | sig { returns(T::Array[Float]) } 62 | def segments 63 | sigils = sigil_count_by_name 64 | [ 65 | T.let(sigils.fetch(:sigil_ignore, 0.0), Float), 66 | T.let(sigils.fetch(:sigil_false, 0.0), Float), 67 | T.let(sigils.fetch(:sigil_true, 0.0), Float), 68 | T.let( 69 | sigils.fetch(:sigil_strict, 0.0) + sigils.fetch(:sigil_strong, 0.0), 70 | Float 71 | ) 72 | ] 73 | end 74 | 75 | sig { returns(T::Hash[Symbol, Float]) } 76 | def sigil_count_by_name 77 | @calculator.sigil_percentages.each_with_object({}) { |e, a| 78 | a[e.fetch(:label)] = e.fetch(:percentage, 0.0).to_f 79 | } 80 | end 81 | end 82 | end 83 | end 84 | -------------------------------------------------------------------------------- /sorbet/rbi/sorbet-typed/lib/minitest/all/minitest.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi sorbet-typed 3 | # 4 | # If you would like to make changes to this file, great! Please upstream any changes you make here: 5 | # 6 | # https://github.com/sorbet/sorbet-typed/edit/master/lib/minitest/all/minitest.rbi 7 | # 8 | # typed: strong 9 | 10 | module Minitest 11 | class Runnable 12 | end 13 | 14 | class Test < Runnable 15 | include Minitest::Assertions 16 | end 17 | end 18 | 19 | module Minitest::Assertions 20 | extend T::Sig 21 | 22 | sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) } 23 | def assert(test, msg = nil); end 24 | 25 | sig do 26 | params( 27 | exp: BasicObject, 28 | msg: T.nilable(String) 29 | ).returns(TrueClass) 30 | end 31 | def assert_empty(exp, msg = nil); end 32 | 33 | sig do 34 | params( 35 | exp: BasicObject, 36 | act: BasicObject, 37 | msg: T.nilable(String) 38 | ).returns(TrueClass) 39 | end 40 | def assert_equal(exp, act, msg = nil); end 41 | 42 | sig do 43 | params( 44 | collection: T::Enumerable[T.untyped], 45 | obj: BasicObject, 46 | msg: T.nilable(String) 47 | ).returns(TrueClass) 48 | end 49 | def assert_includes(collection, obj, msg = nil); end 50 | 51 | sig do 52 | params( 53 | obj: BasicObject, 54 | msg: T.nilable(String) 55 | ).returns(TrueClass) 56 | end 57 | def assert_nil(obj, msg = nil); end 58 | 59 | sig do 60 | params( 61 | exp: T.untyped 62 | ).returns(TrueClass) 63 | end 64 | def assert_raises(*exp); end 65 | 66 | sig { params(test: T.untyped, msg: T.nilable(String)).returns(TrueClass) } 67 | def refute(test, msg = nil); end 68 | 69 | sig do 70 | params( 71 | exp: BasicObject, 72 | msg: T.nilable(String) 73 | ).returns(TrueClass) 74 | end 75 | def refute_empty(exp, msg = nil); end 76 | 77 | sig do 78 | params( 79 | exp: BasicObject, 80 | act: BasicObject, 81 | msg: T.nilable(String) 82 | ).returns(TrueClass) 83 | end 84 | def refute_equal(exp, act, msg = nil); end 85 | 86 | sig do 87 | params( 88 | collection: T::Enumerable[T.untyped], 89 | obj: BasicObject, 90 | msg: T.nilable(String) 91 | ).returns(TrueClass) 92 | end 93 | def refute_includes(collection, obj, msg = nil); end 94 | 95 | sig do 96 | params( 97 | obj: BasicObject, 98 | msg: T.nilable(String) 99 | ).returns(TrueClass) 100 | end 101 | def refute_nil(obj, msg = nil); end 102 | end 103 | -------------------------------------------------------------------------------- /test/fixtures/01.json: -------------------------------------------------------------------------------- 1 | { 2 | "repo": "none", 3 | "sha": "none", 4 | "status": "Success", 5 | "branch": "none", 6 | "timestamp": "1562089286", 7 | "uuid": "0x55a023baad321fdc-0x99ffaa78-0x46d7-0x94ce-0xfe1f166acc0ee1c00x41a7", 8 | "metrics": [ 9 | { 10 | "name": "ruby_typer.unknown..types.input.sends.typed", 11 | "value": 13 12 | }, 13 | { 14 | "name": "ruby_typer.unknown..types.input.files.sigil.false", 15 | "value": 1 16 | }, 17 | { 18 | "name": "ruby_typer.unknown..run.utilization.inblock" 19 | }, 20 | { 21 | "name": "ruby_typer.unknown..run.utilization.major_faults" 22 | }, 23 | { 24 | "name": "ruby_typer.unknown..release.build_timestamp", 25 | "value": 1562028146 26 | }, 27 | { 28 | "name": "ruby_typer.unknown..types.sig.count", 29 | "value": 1552 30 | }, 31 | { 32 | "name": "ruby_typer.unknown..types.input.bytes", 33 | "value": 334794 34 | }, 35 | { 36 | "name": "ruby_typer.unknown..run.utilization.context_switch.involuntary", 37 | "value": 85 38 | }, 39 | { 40 | "name": "ruby_typer.unknown..release.build_scm_commit_count", 41 | "value": 4366 42 | }, 43 | { 44 | "name": "ruby_typer.unknown..run.utilization.user_time.us", 45 | "value": 87170 46 | }, 47 | { 48 | "name": "ruby_typer.unknown..types.input.files.sigil.true", 49 | "value": 4 50 | }, 51 | { 52 | "name": "ruby_typer.unknown..types.input.classes.total", 53 | "value": 3779 54 | }, 55 | { 56 | "name": "ruby_typer.unknown..run.utilization.system_time.us", 57 | "value": 17330 58 | }, 59 | { 60 | "name": "ruby_typer.unknown..run.utilization.context_switch.voluntary" 61 | }, 62 | { 63 | "name": "ruby_typer.unknown..run.utilization.minor_faults", 64 | "value": 11347 65 | }, 66 | { 67 | "name": "ruby_typer.unknown..run.utilization.max_rss", 68 | "value": 45785088 69 | }, 70 | { 71 | "name": "ruby_typer.unknown..run.utilization.oublock" 72 | }, 73 | { 74 | "name": "ruby_typer.unknown..types.input.files.sigil.strong", 75 | "value": 3 76 | }, 77 | { 78 | "name": "ruby_typer.unknown..types.input.methods.typechecked", 79 | "value": 7 80 | }, 81 | { 82 | "name": "ruby_typer.unknown..types.input.files", 83 | "value": 10 84 | }, 85 | { 86 | "name": "ruby_typer.unknown..types.input.methods.total", 87 | "value": 5245 88 | }, 89 | { 90 | "name": "ruby_typer.unknown..types.input.files.sigil.strict", 91 | "value": 1 92 | }, 93 | { 94 | "name": "ruby_typer.unknown..types.input.sends.total", 95 | "value": 18 96 | }, 97 | { 98 | "name": "ruby_typer.unknown..types.input.files.sigil.autogenerated", 99 | "value": 1 100 | } 101 | ] 102 | } 103 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/parallel.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parallel/all/parallel.rbi 9 | # 10 | # parallel-1.19.1 11 | module Parallel 12 | def self.add_progress_bar!(job_factory, options); end 13 | def self.all?(*args, &block); end 14 | def self.any?(*args, &block); end 15 | def self.call_with_index(item, index, options, &block); end 16 | def self.create_workers(job_factory, options, &block); end 17 | def self.each(array, options = nil, &block); end 18 | def self.each_with_index(array, options = nil, &block); end 19 | def self.extract_count_from_options(options); end 20 | def self.flat_map(*args, &block); end 21 | def self.handle_exception(exception, results); end 22 | def self.in_processes(options = nil, &block); end 23 | def self.in_threads(options = nil); end 24 | def self.map(source, options = nil, &block); end 25 | def self.map_with_index(array, options = nil, &block); end 26 | def self.process_incoming_jobs(read, write, job_factory, options, &block); end 27 | def self.replace_worker(job_factory, workers, i, options, blk); end 28 | def self.with_instrumentation(item, index, options); end 29 | def self.work_direct(job_factory, options, &block); end 30 | def self.work_in_processes(job_factory, options, &blk); end 31 | def self.work_in_threads(job_factory, options, &block); end 32 | def self.worker(job_factory, options, &block); end 33 | def self.worker_number; end 34 | def self.worker_number=(worker_num); end 35 | extend Parallel::ProcessorCount 36 | end 37 | module Parallel::ProcessorCount 38 | def physical_processor_count; end 39 | def processor_count; end 40 | end 41 | class Parallel::DeadWorker < StandardError 42 | end 43 | class Parallel::Break < StandardError 44 | end 45 | class Parallel::Kill < StandardError 46 | end 47 | class Parallel::UndumpableException < StandardError 48 | def backtrace; end 49 | def initialize(original); end 50 | end 51 | class Parallel::ExceptionWrapper 52 | def exception; end 53 | def initialize(exception); end 54 | end 55 | class Parallel::Worker 56 | def close_pipes; end 57 | def initialize(read, write, pid); end 58 | def pid; end 59 | def read; end 60 | def stop; end 61 | def thread; end 62 | def thread=(arg0); end 63 | def wait; end 64 | def work(data); end 65 | def write; end 66 | end 67 | class Parallel::JobFactory 68 | def initialize(source, mutex); end 69 | def next; end 70 | def pack(item, index); end 71 | def producer?; end 72 | def queue_wrapper(array); end 73 | def size; end 74 | def unpack(data); end 75 | end 76 | class Parallel::UserInterruptHandler 77 | def self.kill(thing); end 78 | def self.kill_on_ctrl_c(pids, options); end 79 | def self.restore_interrupt(old, signal); end 80 | def self.trap_interrupt(signal); end 81 | end 82 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/rainbow.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rainbow/all/rainbow.rbi 9 | # 10 | # rainbow-3.0.0 11 | module Rainbow 12 | def self.enabled; end 13 | def self.enabled=(value); end 14 | def self.global; end 15 | def self.new; end 16 | def self.uncolor(string); end 17 | end 18 | class Rainbow::StringUtils 19 | def self.uncolor(string); end 20 | def self.wrap_with_sgr(string, codes); end 21 | end 22 | module Rainbow::X11ColorNames 23 | end 24 | class Rainbow::Color 25 | def ground; end 26 | def self.build(ground, values); end 27 | def self.parse_hex_color(hex); end 28 | end 29 | class Rainbow::Color::Indexed < Rainbow::Color 30 | def codes; end 31 | def initialize(ground, num); end 32 | def num; end 33 | end 34 | class Rainbow::Color::Named < Rainbow::Color::Indexed 35 | def initialize(ground, name); end 36 | def self.color_names; end 37 | def self.valid_names; end 38 | end 39 | class Rainbow::Color::RGB < Rainbow::Color::Indexed 40 | def b; end 41 | def code_from_rgb; end 42 | def codes; end 43 | def g; end 44 | def initialize(ground, *values); end 45 | def r; end 46 | def self.to_ansi_domain(value); end 47 | end 48 | class Rainbow::Color::X11Named < Rainbow::Color::RGB 49 | def initialize(ground, name); end 50 | def self.color_names; end 51 | def self.valid_names; end 52 | include Rainbow::X11ColorNames 53 | end 54 | class Rainbow::Presenter < String 55 | def background(*values); end 56 | def bg(*values); end 57 | def black; end 58 | def blink; end 59 | def blue; end 60 | def bold; end 61 | def bright; end 62 | def color(*values); end 63 | def cyan; end 64 | def dark; end 65 | def faint; end 66 | def fg(*values); end 67 | def foreground(*values); end 68 | def green; end 69 | def hide; end 70 | def inverse; end 71 | def italic; end 72 | def magenta; end 73 | def method_missing(method_name, *args); end 74 | def red; end 75 | def reset; end 76 | def respond_to_missing?(method_name, *args); end 77 | def underline; end 78 | def white; end 79 | def wrap_with_sgr(codes); end 80 | def yellow; end 81 | end 82 | class Rainbow::NullPresenter < String 83 | def background(*_values); end 84 | def bg(*_values); end 85 | def black; end 86 | def blink; end 87 | def blue; end 88 | def bold; end 89 | def bright; end 90 | def color(*_values); end 91 | def cyan; end 92 | def dark; end 93 | def faint; end 94 | def fg(*_values); end 95 | def foreground(*_values); end 96 | def green; end 97 | def hide; end 98 | def inverse; end 99 | def italic; end 100 | def magenta; end 101 | def method_missing(method_name, *args); end 102 | def red; end 103 | def reset; end 104 | def respond_to_missing?(method_name, *args); end 105 | def underline; end 106 | def white; end 107 | def yellow; end 108 | end 109 | class Rainbow::Wrapper 110 | def enabled; end 111 | def enabled=(arg0); end 112 | def initialize(enabled = nil); end 113 | def wrap(string); end 114 | end 115 | class Object < BasicObject 116 | def Rainbow(string); end 117 | end 118 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | # Contributor Covenant Code of Conduct 2 | 3 | ## Our Pledge 4 | 5 | In the interest of fostering an open and welcoming environment, we as 6 | contributors and maintainers pledge to making participation in our project and 7 | our community a harassment-free experience for everyone, regardless of age, body 8 | size, disability, ethnicity, gender identity and expression, level of experience, 9 | nationality, personal appearance, race, religion, or sexual identity and 10 | orientation. 11 | 12 | ## Our Standards 13 | 14 | Examples of behavior that contributes to creating a positive environment 15 | include: 16 | 17 | * Using welcoming and inclusive language 18 | * Being respectful of differing viewpoints and experiences 19 | * Gracefully accepting constructive criticism 20 | * Focusing on what is best for the community 21 | * Showing empathy towards other community members 22 | 23 | Examples of unacceptable behavior by participants include: 24 | 25 | * The use of sexualized language or imagery and unwelcome sexual attention or 26 | advances 27 | * Trolling, insulting/derogatory comments, and personal or political attacks 28 | * Public or private harassment 29 | * Publishing others' private information, such as a physical or electronic 30 | address, without explicit permission 31 | * Other conduct which could reasonably be considered inappropriate in a 32 | professional setting 33 | 34 | ## Our Responsibilities 35 | 36 | Project maintainers are responsible for clarifying the standards of acceptable 37 | behavior and are expected to take appropriate and fair corrective action in 38 | response to any instances of unacceptable behavior. 39 | 40 | Project maintainers have the right and responsibility to remove, edit, or 41 | reject comments, commits, code, wiki edits, issues, and other contributions 42 | that are not aligned to this Code of Conduct, or to ban temporarily or 43 | permanently any contributor for other behaviors that they deem inappropriate, 44 | threatening, offensive, or harmful. 45 | 46 | ## Scope 47 | 48 | This Code of Conduct applies both within project spaces and in public spaces 49 | when an individual is representing the project or its community. Examples of 50 | representing a project or community include using an official project e-mail 51 | address, posting via an official social media account, or acting as an appointed 52 | representative at an online or offline event. Representation of a project may be 53 | further defined and clarified by project maintainers. 54 | 55 | ## Enforcement 56 | 57 | Instances of abusive, harassing, or otherwise unacceptable behavior may be 58 | reported by contacting the project team at jared@jaredbeck.com. All 59 | complaints will be reviewed and investigated and will result in a response that 60 | is deemed necessary and appropriate to the circumstances. The project team is 61 | obligated to maintain confidentiality with regard to the reporter of an incident. 62 | Further details of specific enforcement policies may be posted separately. 63 | 64 | Project maintainers who do not follow or enforce the Code of Conduct in good 65 | faith may face temporary or permanent repercussions as determined by other 66 | members of the project's leadership. 67 | 68 | ## Attribution 69 | 70 | This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, 71 | available at [http://contributor-covenant.org/version/1/4][version] 72 | 73 | [homepage]: http://contributor-covenant.org 74 | [version]: http://contributor-covenant.org/version/1/4/ 75 | -------------------------------------------------------------------------------- /sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi sorbet-typed 3 | # 4 | # If you would like to make changes to this file, great! Please upstream any changes you make here: 5 | # 6 | # https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/open3.rbi 7 | # 8 | # typed: strong 9 | 10 | module Open3 11 | sig do 12 | params( 13 | cmd: T.any(String, T::Array[String]), 14 | opts: T.untyped, 15 | block: T.nilable(T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter).void) 16 | ).returns([IO, IO, IO, Process::Waiter]) 17 | end 18 | def self.popen3(*cmd, **opts, &block); end 19 | 20 | sig do 21 | params( 22 | cmd: T.any(String, T::Array[String]), 23 | opts: T.untyped, 24 | block: T.nilable(T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter).void) 25 | ).returns([IO, IO, Process::Waiter]) 26 | end 27 | def self.popen2(*cmd, **opts, &block); end 28 | 29 | sig do 30 | params( 31 | cmd: T.any(String, T::Array[String]), 32 | opts: T.untyped, 33 | block: T.nilable(T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Process::Waiter).void) 34 | ).returns([IO, IO, Process::Waiter]) 35 | end 36 | def self.popen2e(*cmd, **opts, &block); end 37 | 38 | sig do 39 | params( 40 | cmd: T.any(String, T::Array[String]), 41 | stdin_data: T.nilable(String), 42 | binmode: T.any(FalseClass, TrueClass), 43 | opts: T::Hash[Symbol, T.untyped] 44 | ).returns([String, String, Process::Status]) 45 | end 46 | def self.capture3(*cmd, stdin_data: '', binmode: false, **opts); end 47 | 48 | sig do 49 | params( 50 | cmd: T.any(String, T::Array[String]), 51 | stdin_data: T.nilable(String), 52 | binmode: T.any(FalseClass, TrueClass), 53 | opts: T::Hash[Symbol, T.untyped] 54 | ).returns([String, Process::Status]) 55 | end 56 | def self.capture2(*cmd, stdin_data: nil, binmode: false, **opts); end 57 | 58 | sig do 59 | params( 60 | cmd: T.any(String, T::Array[String]), 61 | stdin_data: T.nilable(String), 62 | binmode: T.any(FalseClass, TrueClass), 63 | opts: T::Hash[Symbol, T.untyped] 64 | ).returns([String, Process::Status]) 65 | end 66 | def self.capture2e(*cmd, stdin_data: nil, binmode: false, **opts); end 67 | 68 | sig do 69 | params( 70 | cmds: T.any(String, T::Array[String]), 71 | opts: T.untyped, 72 | block: T.nilable(T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) 73 | ).returns([IO, IO, T::Array[Process::Waiter]]) 74 | end 75 | def self.pipeline_rw(*cmds, **opts, &block); end 76 | 77 | sig do 78 | params( 79 | cmds: T.any(String, T::Array[String]), 80 | opts: T.untyped, 81 | block: T.nilable(T.proc.params(last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) 82 | ).returns([IO, T::Array[Process::Waiter]]) 83 | end 84 | def self.pipeline_r(*cmds, **opts, &block); end 85 | 86 | sig do 87 | params( 88 | cmds: T.any(String, T::Array[String]), 89 | opts: T.untyped, 90 | block: T.nilable(T.proc.params(first_stdin: IO, wait_threads: T::Array[Process::Waiter]).void) 91 | ).returns([IO, T::Array[Process::Waiter]]) 92 | end 93 | def self.pipeline_w(*cmds, **opts, &block); end 94 | 95 | sig do 96 | params( 97 | cmds: T.any(String, T::Array[String]), 98 | opts: T.untyped, 99 | block: T.nilable(T.proc.params(wait_threads: T::Array[Process::Waiter]).void) 100 | ).returns(T::Array[Process::Waiter]) 101 | end 102 | def self.pipeline_start(*cmds, **opts, &block); end 103 | 104 | sig do 105 | params( 106 | cmds: T.any(String, T::Array[String]), 107 | opts: T.untyped 108 | ).returns(T::Array[Process::Status]) 109 | end 110 | def self.pipeline(*cmds, **opts); end 111 | end 112 | -------------------------------------------------------------------------------- /sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi sorbet-typed 3 | # 4 | # If you would like to make changes to this file, great! Please upstream any changes you make here: 5 | # 6 | # https://github.com/sorbet/sorbet-typed/edit/master/lib/rainbow/all/rainbow.rbi 7 | # 8 | # typed: false 9 | 10 | module Rainbow 11 | sig { returns(T::Boolean) } 12 | attr_accessor :enabled 13 | 14 | class Color 15 | sig { returns(Symbol) } 16 | attr_reader :ground 17 | 18 | sig do 19 | params( 20 | ground: Symbol, 21 | values: T.any([Integer], [Integer, Integer, Integer]) 22 | ).returns(Color) 23 | end 24 | def self.build(ground, values); end 25 | 26 | sig { params(hex: String).returns([Integer, Integer, Integer]) } 27 | def self.parse_hex_color(hex); end 28 | 29 | class Indexed < Color 30 | sig { returns(Integer) } 31 | attr_reader :num 32 | 33 | sig { params(ground: Symbol, num: Integer).returns(Indexed) } 34 | def initialize(ground, num); end 35 | 36 | sig { returns(T::Array[Integer]) } 37 | def codes; end 38 | end 39 | 40 | class Named < Indexed 41 | NAMES = T.let(nil, T::Hash[Symbol, Integer]) 42 | 43 | sig { returns(T::Array[Symbol]) } 44 | def self.color_names; end 45 | 46 | sig { returns(String) } 47 | def self.valid_names; end 48 | 49 | sig { params(ground: Symbol, name: Symbol).returns(Named) } 50 | def initialize(ground, name); end 51 | end 52 | 53 | class RGB < Indexed 54 | sig { returns(Integer) } 55 | attr_accessor :r, :g, :b 56 | 57 | sig { params(value: Numeric).returns(Integer) } 58 | def to_ansi_domain(value); end 59 | 60 | sig { params(ground: Symbol, values: Integer).returns(RGB) } 61 | def initialize(ground, *values); end 62 | 63 | sig { returns(T::Array[Integer]) } 64 | def codes; end 65 | end 66 | 67 | class X11Named < RGB 68 | include X11ColorNames 69 | 70 | sig { returns(T::Array[Symbol]) } 71 | def self.color_names; end 72 | 73 | sig { returns(String) } 74 | def self.valid_names; end 75 | 76 | sig { params(ground: Symbol, name: Symbol).returns(X11Named) } 77 | def initialize(ground, name); end 78 | end 79 | end 80 | 81 | sig { returns(Wrapper) } 82 | def self.global; end 83 | 84 | sig { returns(T::Boolean) } 85 | def self.enabled; end 86 | 87 | sig { params(value: T::Boolean).returns(T::Boolean) } 88 | def self.enabled=(value); end 89 | 90 | sig { params(string: String).returns(String) } 91 | def self.uncolor(string); end 92 | 93 | class NullPresenter < String 94 | sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } 95 | def color(*values); end 96 | 97 | sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } 98 | def background(*values); end 99 | 100 | sig { returns(NullPresenter) } 101 | def reset; end 102 | 103 | sig { returns(NullPresenter) } 104 | def bright; end 105 | 106 | sig { returns(NullPresenter) } 107 | def faint; end 108 | 109 | sig { returns(NullPresenter) } 110 | def italic; end 111 | 112 | sig { returns(NullPresenter) } 113 | def underline; end 114 | 115 | sig { returns(NullPresenter) } 116 | def blink; end 117 | 118 | sig { returns(NullPresenter) } 119 | def inverse; end 120 | 121 | sig { returns(NullPresenter) } 122 | def hide; end 123 | 124 | sig { returns(NullPresenter) } 125 | def cross_out; end 126 | 127 | sig { returns(NullPresenter) } 128 | def black; end 129 | 130 | sig { returns(NullPresenter) } 131 | def red; end 132 | 133 | sig { returns(NullPresenter) } 134 | def green; end 135 | 136 | sig { returns(NullPresenter) } 137 | def yellow; end 138 | 139 | sig { returns(NullPresenter) } 140 | def blue; end 141 | 142 | sig { returns(NullPresenter) } 143 | def magenta; end 144 | 145 | sig { returns(NullPresenter) } 146 | def cyan; end 147 | 148 | sig { returns(NullPresenter) } 149 | def white; end 150 | 151 | alias foreground color 152 | alias fg color 153 | alias bg background 154 | alias bold bright 155 | alias dark faint 156 | alias strike cross_out 157 | end 158 | 159 | class Presenter < String 160 | TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer]) 161 | 162 | sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } 163 | def color(*values); end 164 | 165 | sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } 166 | def background(*values); end 167 | 168 | sig { returns(Presenter) } 169 | def reset; end 170 | 171 | sig { returns(Presenter) } 172 | def bright; end 173 | 174 | sig { returns(Presenter) } 175 | def faint; end 176 | 177 | sig { returns(Presenter) } 178 | def italic; end 179 | 180 | sig { returns(Presenter) } 181 | def underline; end 182 | 183 | sig { returns(Presenter) } 184 | def blink; end 185 | 186 | sig { returns(Presenter) } 187 | def inverse; end 188 | 189 | sig { returns(Presenter) } 190 | def hide; end 191 | 192 | sig { returns(Presenter) } 193 | def cross_out; end 194 | 195 | sig { returns(Presenter) } 196 | def black; end 197 | 198 | sig { returns(Presenter) } 199 | def red; end 200 | 201 | sig { returns(Presenter) } 202 | def green; end 203 | 204 | sig { returns(Presenter) } 205 | def yellow; end 206 | 207 | sig { returns(Presenter) } 208 | def blue; end 209 | 210 | sig { returns(Presenter) } 211 | def magenta; end 212 | 213 | sig { returns(Presenter) } 214 | def cyan; end 215 | 216 | sig { returns(Presenter) } 217 | def white; end 218 | 219 | alias foreground color 220 | alias fg color 221 | alias bg background 222 | alias bold bright 223 | alias dark faint 224 | alias strike cross_out 225 | end 226 | 227 | class StringUtils 228 | sig { params(string: String, codes: T::Array[Integer]).returns(String) } 229 | def self.wrap_with_sgr(string, codes); end 230 | 231 | sig { params(string: String).returns(String) } 232 | def uncolor(string); end 233 | end 234 | 235 | VERSION = T.let(nil, String) 236 | 237 | class Wrapper 238 | sig { returns(T::Boolean) } 239 | attr_accessor :enabled 240 | 241 | sig { params(enabled: T::Boolean).returns(Wrapper) } 242 | def initialize(enabled = true); end 243 | 244 | sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) } 245 | def wrap(string); end 246 | end 247 | 248 | module X11ColorNames 249 | NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]]) 250 | end 251 | end 252 | 253 | sig { params(string: String).returns(Rainbow::Presenter) } 254 | def Rainbow(string); end 255 | -------------------------------------------------------------------------------- /.rubocop.yml: -------------------------------------------------------------------------------- 1 | AllCops: 2 | Exclude: 3 | - 'bin/**/*' 4 | - '.git/**/*' 5 | - 'vendor/**/*' 6 | 7 | # Specify the lowest version tested by .travis.yml 8 | TargetRubyVersion: 2.6 9 | 10 | Layout/AlignArguments: 11 | EnforcedStyle: with_fixed_indentation 12 | 13 | Layout/AlignParameters: 14 | EnforcedStyle: with_fixed_indentation 15 | 16 | # Used consistently, both leading and trailing styles are valid, but 17 | # Singlebrook happens to use the trailing style. 18 | Layout/DotPosition: 19 | EnforcedStyle: trailing 20 | 21 | Layout/EmptyLineAfterGuardClause: 22 | Enabled: false 23 | 24 | # This cop has a bug in 0.52.0 25 | # https://github.com/bbatsov/rubocop/issues/5224 26 | Layout/EmptyLinesAroundArguments: 27 | Enabled: false 28 | 29 | # Indent arrays so that the first element is relative to the first position of 30 | # the line where the opening bracket is. 31 | Layout/IndentFirstArrayElement: 32 | EnforcedStyle: consistent 33 | 34 | # In a multiline method call, put the closing parenthesis on its own line. 35 | # The first argument may either be on the first line, or the second. Both of the 36 | # following are correct: 37 | # 38 | # ``` 39 | # # A. correct 40 | # create(:user, 41 | # client: foo, 42 | # long_line: blah 43 | # ) 44 | # 45 | # # B. also correct 46 | # create( 47 | # :user, 48 | # client: foo, 49 | # long_line: blah 50 | # ) 51 | # 52 | # # C. not preferred 53 | # user = create :user, 54 | # client: foo, 55 | # long_line: blah 56 | # ``` 57 | # 58 | # Rubocop supports B, but not A. This project allows both, so this cop is 59 | # disabled. 60 | Layout/MultilineMethodCallBraceLayout: 61 | Enabled: false 62 | 63 | Layout/MultilineMethodCallIndentation: 64 | EnforcedStyle: indented 65 | 66 | Layout/MultilineOperationIndentation: 67 | EnforcedStyle: indented 68 | 69 | # Sometimes splat is convenient, sometimes unnecessary. Too subtle to lint. 70 | Lint/UnneededSplatExpansion: 71 | Enabled: false 72 | 73 | Metrics/AbcSize: 74 | Exclude: 75 | - test/**/* 76 | 77 | # Compared to metrics like `AbcSize` or `CyclomaticComplexity`, number of 78 | # lines is not a useful metric. 79 | Metrics/ClassLength: 80 | Enabled: false 81 | 82 | # Compared to metrics like `AbcSize` or `CyclomaticComplexity`, number of 83 | # lines is not a useful metric. 84 | Metrics/BlockLength: 85 | Enabled: false 86 | 87 | # Compared to metrics like `AbcSize` or `CyclomaticComplexity`, the number of 88 | # lines in a method is not a useful metric. It's common to have very long 89 | # methods (> 50 lines) which are quite simple. For example, a method that 90 | # returns a long string with only a few interpolations. 91 | Metrics/MethodLength: 92 | Enabled: false 93 | 94 | # Compared to metrics like `AbcSize` or `CyclomaticComplexity`, the number of 95 | # lines in a module is not a useful metric. 96 | Metrics/ModuleLength: 97 | Enabled: false 98 | 99 | # Too strict. Not all methods named `set_x` would make sense named `x=`. 100 | Naming/AccessorMethodName: 101 | Enabled: false 102 | 103 | # It is a decades-old convention to use EOS as a heredoc delimiter. There is 104 | # not enough value in changinge this convention. SQL should still be used as 105 | # a delimiter when appropriate. 106 | Naming/HeredocDelimiterNaming: 107 | Enabled: false 108 | 109 | # It is reasonable to use mathematical symbols in comments, or to relish what 110 | # little multilingualism we have in America by using native spellings, like 111 | # "façade" or "naïve". 112 | Style/AsciiComments: 113 | Enabled: false 114 | 115 | # Giving the ivar a leading underscore implies that it should not be 116 | # set/referencd outside of the memoization method. 117 | Naming/MemoizedInstanceVariableName: 118 | EnforcedStyleForLeadingUnderscores: required 119 | 120 | # Sometimes two chars, or even one, is acceptable. 121 | Naming/UncommunicativeMethodParamName: 122 | Enabled: false 123 | 124 | # Use numbers wherever you like in your variables. Who cares. 125 | Naming/VariableNumber: 126 | Enabled: false 127 | 128 | # Use the semantic style. If a block has side effects use `do`, and if it is 129 | # pure use `{}`. This style is too nuanced for a linter, so the cop is 130 | # disabled. 131 | Style/BlockDelimiters: 132 | Enabled: false 133 | 134 | Style/BracesAroundHashParameters: 135 | EnforcedStyle: context_dependent 136 | 137 | Style/ClassAndModuleChildren: 138 | EnforcedStyle: nested 139 | 140 | Style/Documentation: 141 | Exclude: 142 | - 'test/**/*' 143 | 144 | # Use double negation wherever it would otherwise be impractical to convert 145 | # a value to an actual boolean. 146 | Style/DoubleNegation: 147 | Enabled: false 148 | 149 | Style/EmptyElse: 150 | EnforcedStyle: empty 151 | 152 | Style/EmptyMethod: 153 | EnforcedStyle: expanded 154 | 155 | # Concerns: 156 | # 1. In 0.52.0, this complains about `strftime('%x')`. Annotating tokens in 157 | # e.g. strftime would just be duplicating documenation. 158 | # 2. Annotating tokens in long format strings could make such lines very long. 159 | # 3. Annotation is not necessary in format strings with small numbers of tokens. 160 | Style/FormatStringToken: 161 | Enabled: false 162 | 163 | # The decision of when to use a guard clause is too nuanced for a linter. 164 | Style/GuardClause: 165 | Enabled: false 166 | 167 | # Avoid postfix (aka. modifier) conditional operator, except on the simplest 168 | # of lines. This is too nuanced for a linter. 169 | Style/IfUnlessModifier: 170 | Enabled: false 171 | 172 | # When using a multiline proc in a hash (eg. `validates`), I don't want to use 173 | # lambda because then I'd have commas immediately after the "end", like `end,`. 174 | Style/Lambda: 175 | Enabled: false 176 | 177 | # There is a known issue with `MixinGrouping` in rubocop 0.48.0 178 | # https://github.com/bbatsov/rubocop/issues/4172 179 | Style/MixinGrouping: 180 | Enabled: false 181 | 182 | # Disabled, because we like to write tests like: 183 | # 184 | # expect( 185 | # foo :bar, :baz 186 | # ).to # whatever 187 | # 188 | # When there's only one argument, and it's on its own line, there's no problem. 189 | Style/NestedParenthesizedCalls: 190 | Enabled: false 191 | 192 | Style/Next: 193 | MinBodyLength: 5 # The default of 3 is too low for my taste. 194 | 195 | # This is a new cop in rubocop 0.41, and I'm not sure if I want to adopt it yet. 196 | Style/NumericLiteralPrefix: 197 | Enabled: false 198 | 199 | # Use `x > 0` because it is more specific than `x.positive?`. 200 | # However, `x.zero?` is acceptable because it is specific enough. 201 | Style/NumericPredicate: 202 | Enabled: false 203 | 204 | # The decision of when to use slashes `/foo/` or percent-r `%r{foo}` is too 205 | # subtle to lint. Use whichever requires fewer backslash escapes. 206 | Style/RegexpLiteral: 207 | Enabled: false 208 | 209 | # Disabled because it is overzealous in 0.50.0. 210 | # https://github.com/bbatsov/rubocop/issues/4731 211 | Style/SafeNavigation: 212 | Enabled: false 213 | 214 | # The new recommendation to use `acc` and `elem` instead of `a` and `e` is fine, 215 | # if someone wants to change it. For now, it's fine to keep `a` and `e`. 216 | Style/SingleLineBlockParams: 217 | Methods: 218 | - reduce: 219 | - a 220 | - e 221 | - inject: 222 | - a 223 | - e 224 | 225 | Style/StringLiterals: 226 | EnforcedStyle: double_quotes 227 | 228 | Style/TernaryParentheses: 229 | EnforcedStyle: require_parentheses_when_complex 230 | 231 | # This cop has a bug in rubocop 0.62.0: 232 | # https://github.com/rubocop-hq/rubocop/issues/6627 233 | Style/TrailingCommaInArguments: 234 | Enabled: false 235 | 236 | # Predicate methods, aka. question-mark methods, such as `def x?; @x; end` are 237 | # acceptable. See https://github.com/bbatsov/rubocop/issues/2736 for discussion. 238 | Style/TrivialAccessors: 239 | AllowPredicates: true 240 | 241 | # Avoid postfix loops (e.g. `x until y`) except in utterly simple situations. 242 | # This is too nuanced for a linter. 243 | Style/WhileUntilModifier: 244 | Enabled: false 245 | 246 | # We would like to use this cop, but it doesn't work in 0.49. 247 | Style/YodaCondition: 248 | Enabled: false 249 | 250 | # Consider A and B below. A is more like normal English than B. 251 | # 252 | # ``` 253 | # # A 254 | # qar_modules.length > 0 || question_assignments.length > 0 255 | # # B 256 | # !qar_modules.empty? || !question_assignments.empty? 257 | # ``` 258 | Style/ZeroLengthPredicate: 259 | Enabled: false 260 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/ruby-progressbar.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/ruby-progressbar/all/ruby-progressbar.rbi 9 | # 10 | # ruby-progressbar-1.10.1 11 | class ProgressBar 12 | def self.create(*args); end 13 | end 14 | class ProgressBar::Output 15 | def bar; end 16 | def bar=(arg0); end 17 | def clear_string; end 18 | def initialize(options = nil); end 19 | def length; end 20 | def length_calculator; end 21 | def length_calculator=(arg0); end 22 | def log(string); end 23 | def print_and_flush; end 24 | def refresh(options = nil); end 25 | def self.detect(options = nil); end 26 | def stream; end 27 | def stream=(arg0); end 28 | def throttle; end 29 | def throttle=(arg0); end 30 | def with_refresh; end 31 | end 32 | module ProgressBar::Outputs 33 | end 34 | class ProgressBar::Outputs::Tty < ProgressBar::Output 35 | def bar_update_string; end 36 | def clear; end 37 | def default_format; end 38 | def eol; end 39 | def refresh_with_format_change; end 40 | def resolve_format(other_format); end 41 | end 42 | class ProgressBar::Outputs::NonTty < ProgressBar::Output 43 | def bar_update_string; end 44 | def clear; end 45 | def default_format; end 46 | def eol; end 47 | def last_update_length; end 48 | def last_update_length=(arg0); end 49 | def refresh_with_format_change(*arg0); end 50 | def resolve_format(*arg0); end 51 | end 52 | class ProgressBar::Time 53 | def initialize(time = nil); end 54 | def now; end 55 | def time; end 56 | def time=(arg0); end 57 | def unmocked_time_method; end 58 | end 59 | class ProgressBar::Timer 60 | def divide_seconds(seconds); end 61 | def elapsed_seconds; end 62 | def elapsed_whole_seconds; end 63 | def initialize(options = nil); end 64 | def pause; end 65 | def reset; end 66 | def reset?; end 67 | def restart; end 68 | def resume; end 69 | def start; end 70 | def started?; end 71 | def started_at; end 72 | def started_at=(arg0); end 73 | def stop; end 74 | def stopped?; end 75 | def stopped_at; end 76 | def stopped_at=(arg0); end 77 | def time; end 78 | def time=(arg0); end 79 | end 80 | class ProgressBar::InvalidProgressError < RuntimeError 81 | end 82 | class ProgressBar::Progress 83 | def absolute; end 84 | def decrement; end 85 | def finish; end 86 | def finished?; end 87 | def increment; end 88 | def initialize(options = nil); end 89 | def none?; end 90 | def percentage_completed; end 91 | def percentage_completed_with_precision; end 92 | def progress; end 93 | def progress=(new_progress); end 94 | def reset; end 95 | def running_average; end 96 | def running_average=(arg0); end 97 | def smoothing; end 98 | def smoothing=(arg0); end 99 | def start(options = nil); end 100 | def starting_position; end 101 | def starting_position=(arg0); end 102 | def total; end 103 | def total=(new_total); end 104 | def total_with_unknown_indicator; end 105 | def unknown?; end 106 | end 107 | class ProgressBar::Throttle 108 | def choke(options = nil); end 109 | def initialize(options = nil); end 110 | def rate; end 111 | def rate=(arg0); end 112 | def started_at; end 113 | def started_at=(arg0); end 114 | def stopped_at; end 115 | def stopped_at=(arg0); end 116 | def timer; end 117 | def timer=(arg0); end 118 | end 119 | module ProgressBar::Calculators 120 | end 121 | class ProgressBar::Calculators::Length 122 | def calculate_length; end 123 | def current_length; end 124 | def current_length=(arg0); end 125 | def dynamic_width; end 126 | def dynamic_width_stty; end 127 | def dynamic_width_tput; end 128 | def dynamic_width_via_io_object; end 129 | def dynamic_width_via_output_stream_object; end 130 | def dynamic_width_via_system_calls; end 131 | def initialize(options = nil); end 132 | def length; end 133 | def length_changed?; end 134 | def length_override; end 135 | def length_override=(other); end 136 | def output; end 137 | def output=(arg0); end 138 | def reset_length; end 139 | def terminal_width; end 140 | def unix?; end 141 | end 142 | class ProgressBar::Calculators::RunningAverage 143 | def self.calculate(current_average, new_value_to_average, smoothing_factor); end 144 | end 145 | module ProgressBar::Components 146 | end 147 | class ProgressBar::Components::Bar 148 | def bar(length); end 149 | def bar_with_percentage(length); end 150 | def complete_bar(length); end 151 | def complete_bar_with_percentage(length); end 152 | def completed_length; end 153 | def incomplete_space(length); end 154 | def incomplete_string; end 155 | def initialize(options = nil); end 156 | def integrated_percentage_complete_string; end 157 | def length; end 158 | def length=(arg0); end 159 | def progress; end 160 | def progress=(arg0); end 161 | def progress_mark; end 162 | def progress_mark=(arg0); end 163 | def remainder_mark; end 164 | def remainder_mark=(arg0); end 165 | def standard_complete_string; end 166 | def to_s(options = nil); end 167 | def unknown_progress_frame; end 168 | def unknown_string; end 169 | def upa_steps; end 170 | def upa_steps=(arg0); end 171 | end 172 | class ProgressBar::Components::Percentage 173 | def initialize(options = nil); end 174 | def justified_percentage; end 175 | def justified_percentage_with_precision; end 176 | def percentage; end 177 | def percentage_with_precision; end 178 | def progress; end 179 | def progress=(arg0); end 180 | end 181 | class ProgressBar::Components::Rate 182 | def base_rate; end 183 | def elapsed_seconds; end 184 | def initialize(options = nil); end 185 | def progress; end 186 | def progress=(arg0); end 187 | def rate_of_change(format_string = nil); end 188 | def rate_of_change_with_precision; end 189 | def rate_scale; end 190 | def rate_scale=(arg0); end 191 | def scaled_rate; end 192 | def started_at; end 193 | def started_at=(arg0); end 194 | def stopped_at; end 195 | def stopped_at=(arg0); end 196 | def timer; end 197 | def timer=(arg0); end 198 | end 199 | class ProgressBar::Components::Time 200 | def elapsed; end 201 | def elapsed_with_label; end 202 | def estimated; end 203 | def estimated_seconds_remaining; end 204 | def estimated_with_elapsed_fallback; end 205 | def estimated_with_friendly_oob; end 206 | def estimated_with_label; end 207 | def estimated_with_no_oob; end 208 | def estimated_with_unknown_oob; end 209 | def initialize(options = nil); end 210 | def out_of_bounds_time; end 211 | def out_of_bounds_time_format; end 212 | def out_of_bounds_time_format=(format); end 213 | def progress; end 214 | def progress=(arg0); end 215 | def timer; end 216 | def timer=(arg0); end 217 | end 218 | class ProgressBar::Components::Title 219 | def initialize(options = nil); end 220 | def title; end 221 | def title=(arg0); end 222 | end 223 | module ProgressBar::Format 224 | end 225 | class ProgressBar::Format::Molecule 226 | def bar_molecule?; end 227 | def full_key; end 228 | def initialize(letter); end 229 | def key; end 230 | def key=(arg0); end 231 | def lookup_value(environment, length = nil); end 232 | def method_name; end 233 | def method_name=(arg0); end 234 | def non_bar_molecule?; end 235 | end 236 | class ProgressBar::Format::Formatter 237 | def self.process(format_string, max_length, bar); end 238 | end 239 | class ProgressBar::Format::String < String 240 | def bar_molecule_placeholder_length; end 241 | def bar_molecules; end 242 | def displayable_length; end 243 | def molecules; end 244 | def non_bar_molecules; end 245 | end 246 | class ProgressBar::Base 247 | def autofinish; end 248 | def autofinish=(arg0); end 249 | def autostart; end 250 | def autostart=(arg0); end 251 | def bar; end 252 | def bar=(arg0); end 253 | def clear(*args, &block); end 254 | def decrement; end 255 | def finish; end 256 | def finished; end 257 | def finished=(arg0); end 258 | def finished?; end 259 | def format(other); end 260 | def format=(other); end 261 | def increment; end 262 | def initialize(options = nil); end 263 | def inspect; end 264 | def log(*args, &block); end 265 | def output; end 266 | def output=(arg0); end 267 | def pause; end 268 | def paused?; end 269 | def percentage; end 270 | def percentage=(arg0); end 271 | def progress(*args, &block); end 272 | def progress=(new_progress); end 273 | def progress_mark=(mark); end 274 | def progressable; end 275 | def progressable=(arg0); end 276 | def rate; end 277 | def rate=(arg0); end 278 | def refresh(*args, &block); end 279 | def remainder_mark=(mark); end 280 | def reset; end 281 | def resume; end 282 | def start(options = nil); end 283 | def started?; end 284 | def stop; end 285 | def stopped?; end 286 | def time; end 287 | def time=(arg0); end 288 | def timer; end 289 | def timer=(arg0); end 290 | def title; end 291 | def title=(title); end 292 | def title_comp; end 293 | def title_comp=(arg0); end 294 | def to_h; end 295 | def to_s(new_format = nil); end 296 | def total(*args, &block); end 297 | def total=(new_total); end 298 | def update_progress(*args); end 299 | extend Forwardable 300 | end 301 | module ProgressBar::Refinements 302 | end 303 | module ProgressBar::Refinements::Enumerator 304 | end 305 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/minitest.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: true 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/minitest/all/minitest.rbi 9 | # 10 | # minitest-5.13.0 11 | module Minitest 12 | def self.__run(reporter, options); end 13 | def self.after_run(&block); end 14 | 15 | sig { void } 16 | def self.autorun; end 17 | 18 | def self.backtrace_filter; end 19 | def self.backtrace_filter=(arg0); end 20 | def self.clock_time; end 21 | def self.extensions; end 22 | def self.extensions=(arg0); end 23 | def self.filter_backtrace(bt); end 24 | def self.info_signal; end 25 | def self.info_signal=(arg0); end 26 | def self.init_plugins(options); end 27 | def self.load_plugins; end 28 | def self.parallel_executor; end 29 | def self.parallel_executor=(arg0); end 30 | def self.process_args(args = nil); end 31 | def self.reporter; end 32 | def self.reporter=(arg0); end 33 | 34 | sig { params(args: T::Array[String]).returns(T::Boolean) } 35 | def self.run(args = []); end 36 | 37 | def self.run_one_method(klass, method_name); end 38 | end 39 | module Minitest::Parallel 40 | end 41 | class Minitest::Parallel::Executor 42 | def <<(work); end 43 | def initialize(size); end 44 | def shutdown; end 45 | def size; end 46 | def start; end 47 | end 48 | module Minitest::Parallel::Test 49 | def _synchronize; end 50 | end 51 | module Minitest::Parallel::Test::ClassMethods 52 | def run_one_method(klass, method_name, reporter); end 53 | def test_order; end 54 | end 55 | module Minitest::Assertions 56 | def _synchronize; end 57 | def assert(test, msg = nil); end 58 | def assert_empty(obj, msg = nil); end 59 | def assert_equal(exp, act, msg = nil); end 60 | def assert_in_delta(exp, act, delta = nil, msg = nil); end 61 | def assert_in_epsilon(exp, act, epsilon = nil, msg = nil); end 62 | def assert_includes(collection, obj, msg = nil); end 63 | def assert_instance_of(cls, obj, msg = nil); end 64 | def assert_kind_of(cls, obj, msg = nil); end 65 | def assert_match(matcher, obj, msg = nil); end 66 | def assert_mock(mock); end 67 | def assert_nil(obj, msg = nil); end 68 | def assert_operator(o1, op, o2 = nil, msg = nil); end 69 | def assert_output(stdout = nil, stderr = nil); end 70 | def assert_path_exists(path, msg = nil); end 71 | def assert_predicate(o1, op, msg = nil); end 72 | def assert_raises(*exp); end 73 | def assert_respond_to(obj, meth, msg = nil); end 74 | def assert_same(exp, act, msg = nil); end 75 | def assert_send(send_ary, m = nil); end 76 | def assert_silent; end 77 | def assert_throws(sym, msg = nil); end 78 | def capture_io; end 79 | def capture_subprocess_io; end 80 | def diff(exp, act); end 81 | def exception_details(e, msg); end 82 | def fail_after(y, m, d, msg); end 83 | def flunk(msg = nil); end 84 | def message(msg = nil, ending = nil, &default); end 85 | def mu_pp(obj); end 86 | def mu_pp_for_diff(obj); end 87 | def pass(_msg = nil); end 88 | def refute(test, msg = nil); end 89 | def refute_empty(obj, msg = nil); end 90 | def refute_equal(exp, act, msg = nil); end 91 | def refute_in_delta(exp, act, delta = nil, msg = nil); end 92 | def refute_in_epsilon(a, b, epsilon = nil, msg = nil); end 93 | def refute_includes(collection, obj, msg = nil); end 94 | def refute_instance_of(cls, obj, msg = nil); end 95 | def refute_kind_of(cls, obj, msg = nil); end 96 | def refute_match(matcher, obj, msg = nil); end 97 | def refute_nil(obj, msg = nil); end 98 | def refute_operator(o1, op, o2 = nil, msg = nil); end 99 | def refute_path_exists(path, msg = nil); end 100 | def refute_predicate(o1, op, msg = nil); end 101 | def refute_respond_to(obj, meth, msg = nil); end 102 | def refute_same(exp, act, msg = nil); end 103 | def self.diff; end 104 | def self.diff=(o); end 105 | def skip(msg = nil, bt = nil); end 106 | def skip_until(y, m, d, msg); end 107 | def skipped?; end 108 | def things_to_diff(exp, act); end 109 | end 110 | class Minitest::Unit 111 | def self.after_tests(&b); end 112 | def self.autorun; end 113 | end 114 | class Minitest::Unit::TestCase < Minitest::Test 115 | def self.inherited(klass); end 116 | end 117 | class Minitest::Test < Minitest::Runnable 118 | def capture_exceptions; end 119 | def class_name; end 120 | def run; end 121 | def self.i_suck_and_my_tests_are_order_dependent!; end 122 | def self.io_lock; end 123 | def self.io_lock=(arg0); end 124 | def self.make_my_diffs_pretty!; end 125 | def self.parallelize_me!; end 126 | def self.runnable_methods; end 127 | def self.test_order; end 128 | def with_info_handler(&block); end 129 | extend Minitest::Guard 130 | include Minitest::Assertions 131 | include Minitest::Guard 132 | include Minitest::Reportable 133 | include Minitest::Test::LifecycleHooks 134 | end 135 | module Minitest::Test::LifecycleHooks 136 | def after_setup; end 137 | def after_teardown; end 138 | def before_setup; end 139 | def before_teardown; end 140 | def setup; end 141 | def teardown; end 142 | end 143 | class Minitest::Runnable 144 | def assertions; end 145 | def assertions=(arg0); end 146 | def failure; end 147 | def failures; end 148 | def failures=(arg0); end 149 | def initialize(name); end 150 | def marshal_dump; end 151 | def marshal_load(ary); end 152 | def name; end 153 | def name=(o); end 154 | def passed?; end 155 | def result_code; end 156 | def run; end 157 | def self.inherited(klass); end 158 | def self.methods_matching(re); end 159 | def self.on_signal(name, action); end 160 | def self.reset; end 161 | def self.run(reporter, options = nil); end 162 | def self.run_one_method(klass, method_name, reporter); end 163 | def self.runnable_methods; end 164 | def self.runnables; end 165 | def self.with_info_handler(reporter, &block); end 166 | def skipped?; end 167 | def time; end 168 | def time=(arg0); end 169 | def time_it; end 170 | end 171 | module Minitest::Reportable 172 | def class_name; end 173 | def error?; end 174 | def location; end 175 | def passed?; end 176 | def result_code; end 177 | def skipped?; end 178 | end 179 | class Minitest::Result < Minitest::Runnable 180 | def class_name; end 181 | def klass; end 182 | def klass=(arg0); end 183 | def self.from(runnable); end 184 | def source_location; end 185 | def source_location=(arg0); end 186 | def to_s; end 187 | include Minitest::Reportable 188 | end 189 | class Minitest::AbstractReporter 190 | def lock; end 191 | def locked?; end 192 | def passed?; end 193 | def prerecord(klass, name); end 194 | def record(result); end 195 | def report; end 196 | def start; end 197 | def synchronize(&block); end 198 | def try_lock; end 199 | def unlock; end 200 | include Mutex_m 201 | end 202 | class Minitest::Reporter < Minitest::AbstractReporter 203 | def initialize(io = nil, options = nil); end 204 | def io; end 205 | def io=(arg0); end 206 | def options; end 207 | def options=(arg0); end 208 | end 209 | class Minitest::ProgressReporter < Minitest::Reporter 210 | def prerecord(klass, name); end 211 | def record(result); end 212 | end 213 | class Minitest::StatisticsReporter < Minitest::Reporter 214 | def assertions; end 215 | def assertions=(arg0); end 216 | def count; end 217 | def count=(arg0); end 218 | def errors; end 219 | def errors=(arg0); end 220 | def failures; end 221 | def failures=(arg0); end 222 | def initialize(io = nil, options = nil); end 223 | def passed?; end 224 | def record(result); end 225 | def report; end 226 | def results; end 227 | def results=(arg0); end 228 | def skips; end 229 | def skips=(arg0); end 230 | def start; end 231 | def start_time; end 232 | def start_time=(arg0); end 233 | def total_time; end 234 | def total_time=(arg0); end 235 | end 236 | class Minitest::SummaryReporter < Minitest::StatisticsReporter 237 | def aggregated_results(io); end 238 | def binary_string; end 239 | def old_sync; end 240 | def old_sync=(arg0); end 241 | def report; end 242 | def start; end 243 | def statistics; end 244 | def summary; end 245 | def sync; end 246 | def sync=(arg0); end 247 | def to_s; end 248 | end 249 | class Minitest::CompositeReporter < Minitest::AbstractReporter 250 | def <<(reporter); end 251 | def initialize(*reporters); end 252 | def io; end 253 | def passed?; end 254 | def prerecord(klass, name); end 255 | def record(result); end 256 | def report; end 257 | def reporters; end 258 | def reporters=(arg0); end 259 | def start; end 260 | end 261 | class Minitest::Assertion < Exception 262 | def error; end 263 | def location; end 264 | def result_code; end 265 | def result_label; end 266 | end 267 | class Minitest::Skip < Minitest::Assertion 268 | def result_label; end 269 | end 270 | class Minitest::UnexpectedError < Minitest::Assertion 271 | def backtrace; end 272 | def error; end 273 | def exception; end 274 | def exception=(arg0); end 275 | def initialize(exception); end 276 | def message; end 277 | def result_label; end 278 | end 279 | module Minitest::Guard 280 | def jruby?(platform = nil); end 281 | def maglev?(platform = nil); end 282 | def mri?(platform = nil); end 283 | def osx?(platform = nil); end 284 | def rubinius?(platform = nil); end 285 | def windows?(platform = nil); end 286 | end 287 | class Minitest::BacktraceFilter 288 | def filter(bt); end 289 | end 290 | class MockExpectationError < StandardError 291 | end 292 | class Minitest::Mock 293 | def ===(*args, &b); end 294 | def __call(name, data); end 295 | def __respond_to?(*arg0); end 296 | def class(*args, &b); end 297 | def expect(name, retval, args = nil, &blk); end 298 | def initialize(delegator = nil); end 299 | def inspect(*args, &b); end 300 | def instance_eval(*args, &b); end 301 | def instance_variables(*args, &b); end 302 | def method_missing(sym, *args, &block); end 303 | def object_id(*args, &b); end 304 | def public_send(*args, &b); end 305 | def respond_to?(sym, include_private = nil); end 306 | def respond_to_missing?(*args, &b); end 307 | def send(*args, &b); end 308 | def to_s(*args, &b); end 309 | def verify; end 310 | end 311 | class Object < BasicObject 312 | def stub(name, val_or_callable, *block_args); end 313 | include Minitest::Expectations 314 | end 315 | module Minitest::Expectations 316 | def must_be(*args); end 317 | def must_be_close_to(*args); end 318 | def must_be_empty(*args); end 319 | def must_be_instance_of(*args); end 320 | def must_be_kind_of(*args); end 321 | def must_be_nil(*args); end 322 | def must_be_same_as(*args); end 323 | def must_be_silent(*args); end 324 | def must_be_within_delta(*args); end 325 | def must_be_within_epsilon(*args); end 326 | def must_equal(*args); end 327 | def must_include(*args); end 328 | def must_match(*args); end 329 | def must_output(*args); end 330 | def must_raise(*args); end 331 | def must_respond_to(*args); end 332 | def must_throw(*args); end 333 | def path_must_exist(*args); end 334 | def path_wont_exist(*args); end 335 | def wont_be(*args); end 336 | def wont_be_close_to(*args); end 337 | def wont_be_empty(*args); end 338 | def wont_be_instance_of(*args); end 339 | def wont_be_kind_of(*args); end 340 | def wont_be_nil(*args); end 341 | def wont_be_same_as(*args); end 342 | def wont_be_within_delta(*args); end 343 | def wont_be_within_epsilon(*args); end 344 | def wont_equal(*args); end 345 | def wont_include(*args); end 346 | def wont_match(*args); end 347 | def wont_respond_to(*args); end 348 | end 349 | class Minitest::Expectation < Struct 350 | def ctx; end 351 | def ctx=(_); end 352 | def must_be(*args); end 353 | def must_be_close_to(*args); end 354 | def must_be_empty(*args); end 355 | def must_be_instance_of(*args); end 356 | def must_be_kind_of(*args); end 357 | def must_be_nil(*args); end 358 | def must_be_same_as(*args); end 359 | def must_be_silent(*args); end 360 | def must_be_within_epsilon(*args); end 361 | def must_equal(*args); end 362 | def must_include(*args); end 363 | def must_match(*args); end 364 | def must_output(*args); end 365 | def must_raise(*args); end 366 | def must_respond_to(*args); end 367 | def must_throw(*args); end 368 | def path_must_exist(*args); end 369 | def path_wont_exist(*args); end 370 | def self.[](*arg0); end 371 | def self.inspect; end 372 | def self.members; end 373 | def self.new(*arg0); end 374 | def target; end 375 | def target=(_); end 376 | def wont_be(*args); end 377 | def wont_be_close_to(*args); end 378 | def wont_be_empty(*args); end 379 | def wont_be_instance_of(*args); end 380 | def wont_be_kind_of(*args); end 381 | def wont_be_nil(*args); end 382 | def wont_be_same_as(*args); end 383 | def wont_be_within_epsilon(*args); end 384 | def wont_equal(*args); end 385 | def wont_include(*args); end 386 | def wont_match(*args); end 387 | def wont_respond_to(*args); end 388 | end 389 | class Module 390 | def infect_an_assertion(meth, new_name, dont_flip = nil); end 391 | end 392 | module Kernel 393 | def describe(desc, *additional_desc, &block); end 394 | end 395 | class Minitest::Spec < Minitest::Test 396 | def initialize(name); end 397 | def self.current; end 398 | extend Minitest::Spec::DSL 399 | include Minitest::Spec::DSL::InstanceMethods 400 | end 401 | module Minitest::Spec::DSL 402 | def after(_type = nil, &block); end 403 | def before(_type = nil, &block); end 404 | def children; end 405 | def create(name, desc); end 406 | def desc; end 407 | def describe_stack; end 408 | def it(desc = nil, &block); end 409 | def let(name, &block); end 410 | def name; end 411 | def nuke_test_methods!; end 412 | def register_spec_type(*args, &block); end 413 | def self.extended(obj); end 414 | def spec_type(desc, *additional); end 415 | def specify(desc = nil, &block); end 416 | def subject(&block); end 417 | def to_s; end 418 | end 419 | module Minitest::Spec::DSL::InstanceMethods 420 | def _(value = nil, &block); end 421 | def before_setup; end 422 | def expect(value = nil, &block); end 423 | def value(value = nil, &block); end 424 | end 425 | -------------------------------------------------------------------------------- /sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi sorbet-typed 3 | # 4 | # If you would like to make changes to this file, great! Please upstream any changes you make here: 5 | # 6 | # https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/resolv.rbi 7 | # 8 | # typed: strong 9 | 10 | class Resolv 11 | sig { params(name: String).returns(String) } 12 | def self.getaddress(name); end 13 | 14 | sig { params(name: String).returns(T::Array[String]) } 15 | def self.getaddresses(name); end 16 | 17 | sig { params(name: String, block: T.proc.params(address: String).void).void } 18 | def self.each_address(name, &block); end 19 | 20 | sig { params(address: String).returns(String) } 21 | def self.getname(address); end 22 | 23 | sig { params(address: String).returns(T::Array[String]) } 24 | def self.getnames(address); end 25 | 26 | sig { params(address: String, proc: T.proc.params(name: String).void).void } 27 | def self.each_name(address, &proc); end 28 | 29 | sig { params(resolvers: [Hosts, DNS]).void } 30 | def initialize(resolvers=[Hosts.new, DNS.new]); end 31 | 32 | sig { params(name: String).returns(String) } 33 | def getaddress(name); end 34 | 35 | sig { params(name: String).returns(T::Array[String]) } 36 | def getaddresses(name); end 37 | 38 | sig { params(name: String, block: T.proc.params(address: String).void).void } 39 | def each_address(name, &block); end 40 | 41 | sig { params(address: String).returns(String) } 42 | def getname(address); end 43 | 44 | sig { params(address: String).returns(T::Array[String]) } 45 | def getnames(address); end 46 | 47 | sig { params(address: String, proc: T.proc.params(name: String).void).void } 48 | def each_name(address, &proc); end 49 | 50 | class ResolvError < StandardError; end 51 | class ResolvTimeout < Timeout::Error; end 52 | 53 | class Hosts 54 | DefaultFileName = T.let(T.unsafe(nil), String) 55 | 56 | sig { params(filename: String).void } 57 | def initialize(filename = DefaultFileName); end 58 | 59 | sig { params(name: String).returns(String) } 60 | def getaddress(name); end 61 | 62 | sig { params(name: String).returns(T::Array[String]) } 63 | def getaddresses(name); end 64 | 65 | sig { params(name: String, block: T.proc.params(address: String).void).void } 66 | def each_address(name, &block); end 67 | 68 | sig { params(address: String).returns(String) } 69 | def getname(address); end 70 | 71 | sig { params(address: String).returns(T::Array[String]) } 72 | def getnames(address); end 73 | 74 | sig { params(address: String, proc: T.proc.params(name: String).void).void } 75 | def each_name(address, &proc); end 76 | end 77 | 78 | class DNS 79 | Port = T.let(T.unsafe(nil), Integer) 80 | 81 | UDPSize = T.let(T.unsafe(nil), Integer) 82 | 83 | sig do 84 | params( 85 | config_info: T.any( 86 | NilClass, 87 | String, 88 | { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, 89 | { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } 90 | ) 91 | ).returns(Resolv::DNS) 92 | end 93 | def self.open(config_info = nil); end 94 | 95 | sig do 96 | params( 97 | config_info: T.any( 98 | NilClass, 99 | String, 100 | { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, 101 | { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } 102 | ) 103 | ).void 104 | end 105 | def initialize(config_info = nil); end 106 | 107 | sig { params(values: T.any(NilClass, Integer, T::Array[Integer])).void } 108 | def timeouts=(values); end 109 | 110 | sig { void } 111 | def close; end 112 | 113 | sig { params(name: String).returns(String) } 114 | def getaddress(name); end 115 | 116 | sig { params(name: String).returns(T::Array[String]) } 117 | def getaddresses(name); end 118 | 119 | sig { params(name: String, block: T.proc.params(address: String).void).void } 120 | def each_address(name, &block); end 121 | 122 | sig { params(address: String).returns(String) } 123 | def getname(address); end 124 | 125 | sig { params(address: String).returns(T::Array[String]) } 126 | def getnames(address); end 127 | 128 | sig { params(address: String, proc: T.proc.params(name: String).void).void } 129 | def each_name(address, &proc); end 130 | 131 | sig do 132 | params( 133 | name: T.any(String, Resolv::DNS::Name), 134 | typeclass: T.class_of(Resolv::DNS::Resource) 135 | ).returns(Resolv::DNS::Resource) 136 | end 137 | def getresource(name, typeclass); end 138 | 139 | sig do 140 | params( 141 | name: T.any(String, Resolv::DNS::Name), 142 | typeclass: T.class_of(Resolv::DNS::Resource) 143 | ).returns(T::Array[Resolv::DNS::Resource]) 144 | end 145 | def getresources(name, typeclass); end 146 | 147 | sig do 148 | params( 149 | name: T.any(String, Resolv::DNS::Name), 150 | typeclass: T.class_of(Resolv::DNS::Resource), 151 | proc: T.proc.params(resource: Resolv::DNS::Resource).void 152 | ).void 153 | end 154 | def each_resource(name, typeclass, &proc); end 155 | 156 | class DecodeError < StandardError; end 157 | class EncodeError < StandardError; end 158 | 159 | class Name 160 | sig { params(arg: T.any(String, Resolv::DNS::Name)).returns(Resolv::DNS::Name) } 161 | def self.create(arg); end 162 | 163 | sig { params(labels: T::Array[String], absolute: T.any(FalseClass, TrueClass)).void } 164 | def initialize(labels, absolute=true); end 165 | 166 | sig { returns(T.any(FalseClass, TrueClass)) } 167 | def absolute?; end 168 | 169 | sig { params(other: Resolv::DNS::Name).returns(T.any(FalseClass, TrueClass)) } 170 | def subdomain_of?(other); end 171 | end 172 | 173 | class Query; end 174 | 175 | class Resource < Query 176 | sig { returns(T.nilable(Integer)) } 177 | attr_reader :ttl 178 | 179 | sig { void } 180 | def initialize 181 | @ttl = T.let(T.unsafe(nil), T.nilable(Integer)) 182 | end 183 | 184 | class Generic < Resource 185 | sig { params(data: T.untyped).void } 186 | def initialize(data) 187 | @data = T.let(T.unsafe(nil), T.untyped) 188 | end 189 | 190 | sig { returns(T.untyped) } 191 | attr_reader :data 192 | end 193 | 194 | class DomainName < Resource 195 | sig { params(name: String).void } 196 | def initialize(name) 197 | @name = T.let(T.unsafe(nil), String) 198 | end 199 | 200 | sig { returns(String) } 201 | attr_reader :name 202 | end 203 | 204 | class NS < DomainName; end 205 | 206 | class CNAME < DomainName; end 207 | 208 | class SOA < Resource 209 | sig do 210 | params( 211 | mname: String, 212 | rname: String, 213 | serial: Integer, 214 | refresh: Integer, 215 | retry_: Integer, 216 | expire: Integer, 217 | minimum: Integer 218 | ).void 219 | end 220 | def initialize(mname, rname, serial, refresh, retry_, expire, minimum) 221 | @mname = T.let(T.unsafe(nil), String) 222 | @rname = T.let(T.unsafe(nil), String) 223 | @serial = T.let(T.unsafe(nil), Integer) 224 | @refresh = T.let(T.unsafe(nil), Integer) 225 | @retry = T.let(T.unsafe(nil), Integer) 226 | @expire = T.let(T.unsafe(nil), Integer) 227 | @minimum = T.let(T.unsafe(nil), Integer) 228 | end 229 | 230 | sig { returns(String) } 231 | attr_reader :mname 232 | 233 | sig { returns(String) } 234 | attr_reader :rname 235 | 236 | sig { returns(Integer) } 237 | attr_reader :serial 238 | 239 | sig { returns(Integer) } 240 | attr_reader :refresh 241 | 242 | sig { returns(Integer) } 243 | attr_reader :retry 244 | 245 | sig { returns(Integer) } 246 | attr_reader :expire 247 | 248 | sig { returns(Integer) } 249 | attr_reader :minimum 250 | end 251 | 252 | class PTR < DomainName; end 253 | 254 | class HINFO < Resource 255 | sig { params(cpu: String, os: String).void } 256 | def initialize(cpu, os) 257 | @cpu = T.let(T.unsafe(nil), String) 258 | @os = T.let(T.unsafe(nil), String) 259 | end 260 | 261 | sig { returns(String) } 262 | attr_reader :cpu 263 | 264 | sig { returns(String) } 265 | attr_reader :os 266 | end 267 | 268 | class MINFO < Resource 269 | sig { params(rmailbx: String, emailbx: String).void } 270 | def initialize(rmailbx, emailbx) 271 | @rmailbx = T.let(T.unsafe(nil), String) 272 | @emailbx = T.let(T.unsafe(nil), String) 273 | end 274 | 275 | sig { returns(String) } 276 | attr_reader :rmailbx 277 | 278 | sig { returns(String) } 279 | attr_reader :emailbx 280 | end 281 | 282 | class MX < Resource 283 | sig { params(preference: Integer, exchange: String).void } 284 | def initialize(preference, exchange) 285 | @preference = T.let(T.unsafe(nil), Integer) 286 | @exchange = T.let(T.unsafe(nil), String) 287 | end 288 | 289 | sig { returns(Integer) } 290 | attr_reader :preference 291 | 292 | sig { returns(String) } 293 | attr_reader :exchange 294 | end 295 | 296 | class TXT < Resource 297 | sig { params(first_string: String, rest_strings: String).void } 298 | def initialize(first_string, *rest_strings) 299 | @strings = T.let(T.unsafe(nil), T::Array[String]) 300 | end 301 | 302 | sig { returns(T::Array[String]) } 303 | attr_reader :strings 304 | 305 | sig { returns(String) } 306 | def data; end 307 | end 308 | 309 | class LOC < Resource 310 | sig do 311 | params( 312 | version: String, 313 | ssize: T.any(String, Resolv::LOC::Size), 314 | hprecision: T.any(String, Resolv::LOC::Size), 315 | vprecision: T.any(String, Resolv::LOC::Size), 316 | latitude: T.any(String, Resolv::LOC::Coord), 317 | longitude: T.any(String, Resolv::LOC::Coord), 318 | altitude: T.any(String, Resolv::LOC::Alt) 319 | ).void 320 | end 321 | def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude) 322 | @version = T.let(T.unsafe(nil), String) 323 | @ssize = T.let(T.unsafe(nil), Resolv::LOC::Size) 324 | @hprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) 325 | @vprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) 326 | @latitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) 327 | @longitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) 328 | @altitude = T.let(T.unsafe(nil), Resolv::LOC::Alt) 329 | end 330 | 331 | sig { returns(String) } 332 | attr_reader :version 333 | 334 | sig { returns(Resolv::LOC::Size) } 335 | attr_reader :ssize 336 | 337 | sig { returns(Resolv::LOC::Size) } 338 | attr_reader :hprecision 339 | 340 | sig { returns(Resolv::LOC::Size) } 341 | attr_reader :vprecision 342 | 343 | sig { returns(Resolv::LOC::Coord) } 344 | attr_reader :latitude 345 | 346 | sig { returns(Resolv::LOC::Coord) } 347 | attr_reader :longitude 348 | 349 | sig { returns(Resolv::LOC::Alt) } 350 | attr_reader :altitude 351 | end 352 | 353 | class ANY < Query; end 354 | 355 | module IN 356 | class A < Resource 357 | sig { params(address: String).void } 358 | def initialize(address) 359 | @address = T.let(T.unsafe(nil), Resolv::IPv4) 360 | end 361 | 362 | sig { returns(Resolv::IPv4) } 363 | attr_reader :address 364 | end 365 | 366 | class WKS < Resource 367 | sig { params(address: String, protocol: Integer, bitmap: String).void } 368 | def initialize(address, protocol, bitmap) 369 | @address = T.let(T.unsafe(nil), Resolv::IPv4) 370 | @protocol = T.let(T.unsafe(nil), Integer) 371 | @bitmap = T.let(T.unsafe(nil), String) 372 | end 373 | 374 | sig { returns(Resolv::IPv4) } 375 | attr_reader :address 376 | 377 | sig { returns(Integer) } 378 | attr_reader :protocol 379 | 380 | sig { returns(String) } 381 | attr_reader :bitmap 382 | end 383 | 384 | class AAAA < Resource 385 | sig { params(address: String).void } 386 | def initialize(address) 387 | @address = T.let(T.unsafe(nil), Resolv::IPv6) 388 | end 389 | 390 | sig { returns(Resolv::IPv6) } 391 | attr_reader :address 392 | end 393 | 394 | class SRV < Resource 395 | # Create a SRV resource record. 396 | # 397 | # See the documentation for #priority, #weight, #port and #target 398 | # for +priority+, +weight+, +port and +target+ respectively. 399 | 400 | sig do 401 | params( 402 | priority: T.any(Integer, String), 403 | weight: T.any(Integer, String), 404 | port: T.any(Integer, String), 405 | target: T.any(String, Resolv::DNS::Name) 406 | ).void 407 | end 408 | def initialize(priority, weight, port, target) 409 | @priority = T.let(T.unsafe(nil), Integer) 410 | @weight = T.let(T.unsafe(nil), Integer) 411 | @port = T.let(T.unsafe(nil), Integer) 412 | @target = T.let(T.unsafe(nil), Resolv::DNS::Name) 413 | end 414 | 415 | sig { returns(Integer) } 416 | attr_reader :priority 417 | 418 | sig { returns(Integer) } 419 | attr_reader :weight 420 | 421 | sig { returns(Integer) } 422 | attr_reader :port 423 | 424 | sig { returns(Resolv::DNS::Name) } 425 | attr_reader :target 426 | end 427 | end 428 | end 429 | end 430 | 431 | class IPv4 432 | Regex256 = T.let(T.unsafe(nil), Regexp) 433 | Regex = T.let(T.unsafe(nil), Regexp) 434 | 435 | sig { params(arg: T.any(String, Resolv::IPv4)).returns(Resolv::IPv4) } 436 | def self.create(arg); end 437 | 438 | sig { params(address: String).void } 439 | def initialize(address) 440 | @address = T.let(T.unsafe(nil), String) 441 | end 442 | 443 | sig { returns(String) } 444 | attr_reader :address 445 | 446 | sig { returns(DNS::Name) } 447 | def to_name; end 448 | end 449 | 450 | class IPv6 451 | Regex_8Hex = T.let(T.unsafe(nil), Regexp) 452 | Regex_CompressedHex = T.let(T.unsafe(nil), Regexp) 453 | Regex_6Hex4Dec = T.let(T.unsafe(nil), Regexp) 454 | Regex_CompressedHex4Dec = T.let(T.unsafe(nil), Regexp) 455 | Regex = T.let(T.unsafe(nil), Regexp) 456 | 457 | sig { params(arg: T.any(String, Resolv::IPv6)).returns(Resolv::IPv6) } 458 | def self.create(arg); end 459 | 460 | sig { params(address: String).void } 461 | def initialize(address) 462 | @address = T.let(T.unsafe(nil), String) 463 | end 464 | 465 | sig { returns(String) } 466 | attr_reader :address 467 | 468 | sig { returns(DNS::Name) } 469 | def to_name; end 470 | end 471 | 472 | class MDNS < DNS 473 | Port = T.let(T.unsafe(nil), Integer) 474 | AddressV4 = T.let(T.unsafe(nil), String) 475 | AddressV6 = T.let(T.unsafe(nil), String) 476 | Addresses = T.let(T.unsafe(nil), [[String, Integer], [String, Integer]]) 477 | 478 | sig do 479 | params( 480 | config_info: T.any( 481 | NilClass, 482 | { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, 483 | { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } 484 | ) 485 | ).void 486 | end 487 | def initialize(config_info = nil); end 488 | end 489 | 490 | module LOC 491 | class Size 492 | Regex = T.let(T.unsafe(nil), Regexp) 493 | 494 | sig { params(arg: T.any(String, Resolv::LOC::Size)).returns(Resolv::LOC::Size) } 495 | def self.create(arg); end 496 | 497 | sig { params(scalar: String).void } 498 | def initialize(scalar) 499 | @scalar = T.let(T.unsafe(nil), String) 500 | end 501 | 502 | sig { returns(String) } 503 | attr_reader :scalar 504 | end 505 | 506 | class Coord 507 | Regex = T.let(T.unsafe(nil), Regexp) 508 | 509 | sig { params(arg: T.any(String, Resolv::LOC::Coord)).returns(Resolv::LOC::Coord) } 510 | def self.create(arg); end 511 | 512 | sig { params(coordinates: String, orientation: T.enum(%w[lat lon])).void } 513 | def initialize(coordinates, orientation) 514 | @coordinates = T.let(T.unsafe(nil), String) 515 | @orientation = T.let(T.unsafe(nil), T.enum(%w[lat lon])) 516 | end 517 | 518 | sig { returns(String) } 519 | attr_reader :coordinates 520 | 521 | sig { returns(T.enum(%w[lat lon])) } 522 | attr_reader :orientation 523 | end 524 | 525 | class Alt 526 | Regex = T.let(T.unsafe(nil), Regexp) 527 | 528 | sig { params(arg: T.any(String, Resolv::LOC::Alt)).returns(Resolv::LOC::Alt) } 529 | def self.create(arg); end 530 | 531 | sig { params(altitude: String).void } 532 | def initialize(altitude) 533 | @altitude = T.let(T.unsafe(nil), String) 534 | end 535 | 536 | sig { returns(String) } 537 | attr_reader :altitude 538 | end 539 | end 540 | 541 | DefaultResolver = T.let(T.unsafe(nil), Resolv) 542 | AddressRegex = T.let(T.unsafe(nil), Regexp) 543 | end 544 | -------------------------------------------------------------------------------- /sorbet/rbi/gems/parser.rbi: -------------------------------------------------------------------------------- 1 | # This file is autogenerated. Do not edit it by hand. Regenerate it with: 2 | # srb rbi gems 3 | 4 | # typed: strong 5 | # 6 | # If you would like to make changes to this file, great! Please create the gem's shim here: 7 | # 8 | # https://github.com/sorbet/sorbet-typed/new/master?filename=lib/parser/all/parser.rbi 9 | # 10 | # parser-2.7.0.1 11 | module Parser 12 | end 13 | module Parser::Deprecation 14 | def warn_of_deprecation; end 15 | def warned_of_deprecation=(arg0); end 16 | end 17 | module Parser::AST 18 | end 19 | class Parser::AST::Node < AST::Node 20 | def assign_properties(properties); end 21 | def loc; end 22 | def location; end 23 | end 24 | class Parser::AST::Processor < AST::Processor 25 | def on_alias(node); end 26 | def on_and(node); end 27 | def on_and_asgn(node); end 28 | def on_arg(node); end 29 | def on_arg_expr(node); end 30 | def on_args(node); end 31 | def on_argument(node); end 32 | def on_array(node); end 33 | def on_array_pattern(node); end 34 | def on_array_pattern_with_tail(node); end 35 | def on_back_ref(node); end 36 | def on_begin(node); end 37 | def on_block(node); end 38 | def on_block_pass(node); end 39 | def on_blockarg(node); end 40 | def on_blockarg_expr(node); end 41 | def on_break(node); end 42 | def on_case(node); end 43 | def on_case_match(node); end 44 | def on_casgn(node); end 45 | def on_class(node); end 46 | def on_const(node); end 47 | def on_const_pattern(node); end 48 | def on_csend(node); end 49 | def on_cvar(node); end 50 | def on_cvasgn(node); end 51 | def on_def(node); end 52 | def on_defined?(node); end 53 | def on_defs(node); end 54 | def on_dstr(node); end 55 | def on_dsym(node); end 56 | def on_eflipflop(node); end 57 | def on_ensure(node); end 58 | def on_erange(node); end 59 | def on_for(node); end 60 | def on_gvar(node); end 61 | def on_gvasgn(node); end 62 | def on_hash(node); end 63 | def on_hash_pattern(node); end 64 | def on_if(node); end 65 | def on_if_guard(node); end 66 | def on_iflipflop(node); end 67 | def on_in_match(node); end 68 | def on_in_pattern(node); end 69 | def on_index(node); end 70 | def on_indexasgn(node); end 71 | def on_irange(node); end 72 | def on_ivar(node); end 73 | def on_ivasgn(node); end 74 | def on_kwarg(node); end 75 | def on_kwbegin(node); end 76 | def on_kwoptarg(node); end 77 | def on_kwrestarg(node); end 78 | def on_kwsplat(node); end 79 | def on_lambda(node); end 80 | def on_lvar(node); end 81 | def on_lvasgn(node); end 82 | def on_masgn(node); end 83 | def on_match_alt(node); end 84 | def on_match_as(node); end 85 | def on_match_current_line(node); end 86 | def on_match_rest(node); end 87 | def on_match_var(node); end 88 | def on_match_with_lvasgn(node); end 89 | def on_mlhs(node); end 90 | def on_module(node); end 91 | def on_next(node); end 92 | def on_not(node); end 93 | def on_nth_ref(node); end 94 | def on_numblock(node); end 95 | def on_op_asgn(node); end 96 | def on_optarg(node); end 97 | def on_or(node); end 98 | def on_or_asgn(node); end 99 | def on_pair(node); end 100 | def on_pin(node); end 101 | def on_postexe(node); end 102 | def on_preexe(node); end 103 | def on_procarg0(node); end 104 | def on_redo(node); end 105 | def on_regexp(node); end 106 | def on_resbody(node); end 107 | def on_rescue(node); end 108 | def on_restarg(node); end 109 | def on_restarg_expr(node); end 110 | def on_retry(node); end 111 | def on_return(node); end 112 | def on_sclass(node); end 113 | def on_send(node); end 114 | def on_shadowarg(node); end 115 | def on_splat(node); end 116 | def on_super(node); end 117 | def on_undef(node); end 118 | def on_unless_guard(node); end 119 | def on_until(node); end 120 | def on_until_post(node); end 121 | def on_var(node); end 122 | def on_vasgn(node); end 123 | def on_when(node); end 124 | def on_while(node); end 125 | def on_while_post(node); end 126 | def on_xstr(node); end 127 | def on_yield(node); end 128 | def process_argument_node(node); end 129 | def process_regular_node(node); end 130 | def process_var_asgn_node(node); end 131 | def process_variable_node(node); end 132 | end 133 | module Parser::Meta 134 | end 135 | module Parser::Source 136 | end 137 | class Parser::Source::Buffer 138 | def column_for_position(position); end 139 | def decompose_position(position); end 140 | def first_line; end 141 | def initialize(name, first_line = nil); end 142 | def last_line; end 143 | def line_begins; end 144 | def line_for(position); end 145 | def line_for_position(position); end 146 | def line_range(lineno); end 147 | def name; end 148 | def raw_source=(input); end 149 | def read; end 150 | def self.recognize_encoding(string); end 151 | def self.reencode_string(input); end 152 | def slice(range); end 153 | def source; end 154 | def source=(input); end 155 | def source_line(lineno); end 156 | def source_lines; end 157 | def source_range; end 158 | end 159 | class Parser::Source::Range 160 | def <=>(other); end 161 | def adjust(begin_pos: nil, end_pos: nil); end 162 | def begin; end 163 | def begin_pos; end 164 | def column; end 165 | def column_range; end 166 | def contained?(other); end 167 | def contains?(other); end 168 | def crossing?(other); end 169 | def disjoint?(other); end 170 | def empty?; end 171 | def end; end 172 | def end_pos; end 173 | def first_line; end 174 | def initialize(source_buffer, begin_pos, end_pos); end 175 | def inspect; end 176 | def intersect(other); end 177 | def is?(*what); end 178 | def join(other); end 179 | def last_column; end 180 | def last_line; end 181 | def length; end 182 | def line; end 183 | def overlaps?(other); end 184 | def resize(new_size); end 185 | def size; end 186 | def source; end 187 | def source_buffer; end 188 | def source_line; end 189 | def to_a; end 190 | def to_s; end 191 | def with(begin_pos: nil, end_pos: nil); end 192 | include Comparable 193 | end 194 | class Parser::Source::Comment 195 | def ==(other); end 196 | def document?; end 197 | def initialize(range); end 198 | def inline?; end 199 | def inspect; end 200 | def loc; end 201 | def location; end 202 | def self.associate(ast, comments); end 203 | def self.associate_locations(ast, comments); end 204 | def text; end 205 | def type; end 206 | end 207 | class Parser::Source::Comment::Associator 208 | def advance_comment; end 209 | def advance_through_directives; end 210 | def associate; end 211 | def associate_and_advance_comment(node); end 212 | def associate_locations; end 213 | def current_comment_before?(node); end 214 | def current_comment_before_end?(node); end 215 | def current_comment_decorates?(node); end 216 | def do_associate; end 217 | def initialize(ast, comments); end 218 | def process_leading_comments(node); end 219 | def process_trailing_comments(node); end 220 | def skip_directives; end 221 | def skip_directives=(arg0); end 222 | def visit(node); end 223 | end 224 | class Parser::Source::Rewriter 225 | def active_clobber; end 226 | def active_clobber=(value); end 227 | def active_insertions; end 228 | def active_insertions=(value); end 229 | def active_queue; end 230 | def adjacent?(range1, range2); end 231 | def adjacent_insertion_mask(range); end 232 | def adjacent_insertions?(range); end 233 | def adjacent_position_mask(range); end 234 | def adjacent_updates?(range); end 235 | def append(action); end 236 | def can_merge?(action, existing); end 237 | def clobbered_insertion?(insertion); end 238 | def clobbered_position_mask(range); end 239 | def diagnostics; end 240 | def in_transaction?; end 241 | def initialize(source_buffer); end 242 | def insert_after(range, content); end 243 | def insert_after_multi(range, content); end 244 | def insert_before(range, content); end 245 | def insert_before_multi(range, content); end 246 | def merge_actions!(action, existing); end 247 | def merge_actions(action, existing); end 248 | def merge_replacements(actions); end 249 | def process; end 250 | def raise_clobber_error(action, existing); end 251 | def record_insertion(range); end 252 | def record_replace(range); end 253 | def remove(range); end 254 | def replace(range, content); end 255 | def replace_actions(old, updated); end 256 | def replace_compatible_with_insertion?(replace, insertion); end 257 | def source_buffer; end 258 | def transaction; end 259 | def wrap(range, before, after); end 260 | extend Parser::Deprecation 261 | end 262 | class Parser::Source::Rewriter::Action 263 | def <=>(other); end 264 | def allow_multiple_insertions; end 265 | def allow_multiple_insertions?; end 266 | def initialize(range, replacement = nil, allow_multiple_insertions = nil, order = nil); end 267 | def order; end 268 | def range; end 269 | def replacement; end 270 | def to_s; end 271 | include Comparable 272 | end 273 | class Parser::Source::TreeRewriter 274 | def check_policy_validity; end 275 | def check_range_validity(range); end 276 | def combine(range, attributes); end 277 | def diagnostics; end 278 | def enforce_policy(event); end 279 | def in_transaction?; end 280 | def initialize(source_buffer, crossing_deletions: nil, different_replacements: nil, swallowed_insertions: nil); end 281 | def insert_after(range, content); end 282 | def insert_after_multi(range, text); end 283 | def insert_before(range, content); end 284 | def insert_before_multi(range, text); end 285 | def process; end 286 | def remove(range); end 287 | def replace(range, content); end 288 | def source_buffer; end 289 | def transaction; end 290 | def trigger_policy(event, range: nil, conflict: nil, **arguments); end 291 | def wrap(range, insert_before, insert_after); end 292 | extend Parser::Deprecation 293 | end 294 | class Parser::Source::TreeRewriter::Action 295 | def call_enforcer_for_merge(action); end 296 | def combine(action); end 297 | def do_combine(action); end 298 | def fuse_deletions(action, fusible, other_sibblings); end 299 | def initialize(range, enforcer, insert_before: nil, replacement: nil, insert_after: nil, children: nil); end 300 | def insert_after; end 301 | def insert_before; end 302 | def insertion?; end 303 | def merge(action); end 304 | def ordered_replacements; end 305 | def place_in_hierachy(action); end 306 | def range; end 307 | def relationship_with(action); end 308 | def replacement; end 309 | def swallow(children); end 310 | def with(range: nil, children: nil, insert_before: nil, replacement: nil, insert_after: nil); end 311 | end 312 | class Parser::Source::Map 313 | def ==(other); end 314 | def column; end 315 | def expression; end 316 | def first_line; end 317 | def initialize(expression); end 318 | def initialize_copy(other); end 319 | def last_column; end 320 | def last_line; end 321 | def line; end 322 | def node; end 323 | def node=(node); end 324 | def to_hash; end 325 | def update_expression(expression_l); end 326 | def with(&block); end 327 | def with_expression(expression_l); end 328 | end 329 | class Parser::Source::Map::Operator < Parser::Source::Map 330 | def initialize(operator, expression); end 331 | def operator; end 332 | end 333 | class Parser::Source::Map::Collection < Parser::Source::Map 334 | def begin; end 335 | def end; end 336 | def initialize(begin_l, end_l, expression_l); end 337 | end 338 | class Parser::Source::Map::Constant < Parser::Source::Map 339 | def double_colon; end 340 | def initialize(double_colon, name, expression); end 341 | def name; end 342 | def operator; end 343 | def update_operator(operator_l); end 344 | def with_operator(operator_l); end 345 | end 346 | class Parser::Source::Map::Variable < Parser::Source::Map 347 | def initialize(name_l, expression_l = nil); end 348 | def name; end 349 | def operator; end 350 | def update_operator(operator_l); end 351 | def with_operator(operator_l); end 352 | end 353 | class Parser::Source::Map::Keyword < Parser::Source::Map 354 | def begin; end 355 | def end; end 356 | def initialize(keyword_l, begin_l, end_l, expression_l); end 357 | def keyword; end 358 | end 359 | class Parser::Source::Map::Definition < Parser::Source::Map 360 | def end; end 361 | def initialize(keyword_l, operator_l, name_l, end_l); end 362 | def keyword; end 363 | def name; end 364 | def operator; end 365 | end 366 | class Parser::Source::Map::Send < Parser::Source::Map 367 | def begin; end 368 | def dot; end 369 | def end; end 370 | def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end 371 | def operator; end 372 | def selector; end 373 | def update_operator(operator_l); end 374 | def with_operator(operator_l); end 375 | end 376 | class Parser::Source::Map::Index < Parser::Source::Map 377 | def begin; end 378 | def end; end 379 | def initialize(begin_l, end_l, expression_l); end 380 | def operator; end 381 | def update_operator(operator_l); end 382 | def with_operator(operator_l); end 383 | end 384 | class Parser::Source::Map::Condition < Parser::Source::Map 385 | def begin; end 386 | def else; end 387 | def end; end 388 | def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end 389 | def keyword; end 390 | end 391 | class Parser::Source::Map::Ternary < Parser::Source::Map 392 | def colon; end 393 | def initialize(question_l, colon_l, expression_l); end 394 | def question; end 395 | end 396 | class Parser::Source::Map::For < Parser::Source::Map 397 | def begin; end 398 | def end; end 399 | def in; end 400 | def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end 401 | def keyword; end 402 | end 403 | class Parser::Source::Map::RescueBody < Parser::Source::Map 404 | def assoc; end 405 | def begin; end 406 | def initialize(keyword_l, assoc_l, begin_l, expression_l); end 407 | def keyword; end 408 | end 409 | class Parser::Source::Map::Heredoc < Parser::Source::Map 410 | def heredoc_body; end 411 | def heredoc_end; end 412 | def initialize(begin_l, body_l, end_l); end 413 | end 414 | class Parser::Source::Map::ObjcKwarg < Parser::Source::Map 415 | def argument; end 416 | def initialize(keyword_l, operator_l, argument_l, expression_l); end 417 | def keyword; end 418 | def operator; end 419 | end 420 | class Parser::SyntaxError < StandardError 421 | def diagnostic; end 422 | def initialize(diagnostic); end 423 | end 424 | class Parser::ClobberingError < RuntimeError 425 | end 426 | class Parser::Diagnostic 427 | def arguments; end 428 | def first_line_only(range); end 429 | def highlights; end 430 | def initialize(level, reason, arguments, location, highlights = nil); end 431 | def last_line_only(range); end 432 | def level; end 433 | def location; end 434 | def message; end 435 | def reason; end 436 | def render; end 437 | def render_line(range, ellipsis = nil, range_end = nil); end 438 | end 439 | class Parser::Diagnostic::Engine 440 | def all_errors_are_fatal; end 441 | def all_errors_are_fatal=(arg0); end 442 | def consumer; end 443 | def consumer=(arg0); end 444 | def ignore?(diagnostic); end 445 | def ignore_warnings; end 446 | def ignore_warnings=(arg0); end 447 | def initialize(consumer = nil); end 448 | def process(diagnostic); end 449 | def raise?(diagnostic); end 450 | end 451 | class Parser::StaticEnvironment 452 | def declare(name); end 453 | def declare_forward_args; end 454 | def declared?(name); end 455 | def declared_forward_args?; end 456 | def extend_dynamic; end 457 | def extend_static; end 458 | def initialize; end 459 | def reset; end 460 | def unextend; end 461 | end 462 | class Parser::Lexer 463 | def advance; end 464 | def arg_or_cmdarg(cmd_state); end 465 | def cmdarg; end 466 | def cmdarg=(arg0); end 467 | def command_start; end 468 | def command_start=(arg0); end 469 | def comments; end 470 | def comments=(arg0); end 471 | def cond; end 472 | def cond=(arg0); end 473 | def context; end 474 | def context=(arg0); end 475 | def dedent_level; end 476 | def diagnostic(type, reason, arguments = nil, location = nil, highlights = nil); end 477 | def diagnostics; end 478 | def diagnostics=(arg0); end 479 | def emit(type, value = nil, s = nil, e = nil); end 480 | def emit_comment(s = nil, e = nil); end 481 | def emit_do(do_block = nil); end 482 | def emit_table(table, s = nil, e = nil); end 483 | def encode_escape(ord); end 484 | def encoding; end 485 | def eof_codepoint?(point); end 486 | def force_utf32; end 487 | def force_utf32=(arg0); end 488 | def in_kwarg; end 489 | def in_kwarg=(arg0); end 490 | def initialize(version); end 491 | def literal; end 492 | def next_state_for_literal(literal); end 493 | def pop_cmdarg; end 494 | def pop_cond; end 495 | def pop_literal; end 496 | def push_cmdarg; end 497 | def push_cond; end 498 | def push_literal(*args); end 499 | def range(s = nil, e = nil); end 500 | def reset(reset_state = nil); end 501 | def self._lex_eof_trans; end 502 | def self._lex_eof_trans=(arg0); end 503 | def self._lex_from_state_actions; end 504 | def self._lex_from_state_actions=(arg0); end 505 | def self._lex_index_offsets; end 506 | def self._lex_index_offsets=(arg0); end 507 | def self._lex_indicies; end 508 | def self._lex_indicies=(arg0); end 509 | def self._lex_key_spans; end 510 | def self._lex_key_spans=(arg0); end 511 | def self._lex_to_state_actions; end 512 | def self._lex_to_state_actions=(arg0); end 513 | def self._lex_trans_actions; end 514 | def self._lex_trans_actions=(arg0); end 515 | def self._lex_trans_keys; end 516 | def self._lex_trans_keys=(arg0); end 517 | def self._lex_trans_targs; end 518 | def self._lex_trans_targs=(arg0); end 519 | def self.lex_en_expr_arg; end 520 | def self.lex_en_expr_arg=(arg0); end 521 | def self.lex_en_expr_beg; end 522 | def self.lex_en_expr_beg=(arg0); end 523 | def self.lex_en_expr_cmdarg; end 524 | def self.lex_en_expr_cmdarg=(arg0); end 525 | def self.lex_en_expr_dot; end 526 | def self.lex_en_expr_dot=(arg0); end 527 | def self.lex_en_expr_end; end 528 | def self.lex_en_expr_end=(arg0); end 529 | def self.lex_en_expr_endarg; end 530 | def self.lex_en_expr_endarg=(arg0); end 531 | def self.lex_en_expr_endfn; end 532 | def self.lex_en_expr_endfn=(arg0); end 533 | def self.lex_en_expr_fname; end 534 | def self.lex_en_expr_fname=(arg0); end 535 | def self.lex_en_expr_labelarg; end 536 | def self.lex_en_expr_labelarg=(arg0); end 537 | def self.lex_en_expr_mid; end 538 | def self.lex_en_expr_mid=(arg0); end 539 | def self.lex_en_expr_value; end 540 | def self.lex_en_expr_value=(arg0); end 541 | def self.lex_en_expr_variable; end 542 | def self.lex_en_expr_variable=(arg0); end 543 | def self.lex_en_interp_backslash_delimited; end 544 | def self.lex_en_interp_backslash_delimited=(arg0); end 545 | def self.lex_en_interp_backslash_delimited_words; end 546 | def self.lex_en_interp_backslash_delimited_words=(arg0); end 547 | def self.lex_en_interp_string; end 548 | def self.lex_en_interp_string=(arg0); end 549 | def self.lex_en_interp_words; end 550 | def self.lex_en_interp_words=(arg0); end 551 | def self.lex_en_leading_dot; end 552 | def self.lex_en_leading_dot=(arg0); end 553 | def self.lex_en_line_begin; end 554 | def self.lex_en_line_begin=(arg0); end 555 | def self.lex_en_line_comment; end 556 | def self.lex_en_line_comment=(arg0); end 557 | def self.lex_en_plain_backslash_delimited; end 558 | def self.lex_en_plain_backslash_delimited=(arg0); end 559 | def self.lex_en_plain_backslash_delimited_words; end 560 | def self.lex_en_plain_backslash_delimited_words=(arg0); end 561 | def self.lex_en_plain_string; end 562 | def self.lex_en_plain_string=(arg0); end 563 | def self.lex_en_plain_words; end 564 | def self.lex_en_plain_words=(arg0); end 565 | def self.lex_en_regexp_modifiers; end 566 | def self.lex_en_regexp_modifiers=(arg0); end 567 | def self.lex_error; end 568 | def self.lex_error=(arg0); end 569 | def self.lex_start; end 570 | def self.lex_start=(arg0); end 571 | def source_buffer; end 572 | def source_buffer=(source_buffer); end 573 | def stack_pop; end 574 | def state; end 575 | def state=(state); end 576 | def static_env; end 577 | def static_env=(arg0); end 578 | def tok(s = nil, e = nil); end 579 | def tokens; end 580 | def tokens=(arg0); end 581 | def version?(*versions); end 582 | end 583 | class Parser::Lexer::Literal 584 | def backslash_delimited?; end 585 | def clear_buffer; end 586 | def coerce_encoding(string); end 587 | def dedent_level; end 588 | def delimiter?(delimiter); end 589 | def emit(token, type, s, e); end 590 | def emit_start_tok; end 591 | def end_interp_brace_and_try_closing; end 592 | def extend_content; end 593 | def extend_space(ts, te); end 594 | def extend_string(string, ts, te); end 595 | def flush_string; end 596 | def heredoc?; end 597 | def heredoc_e; end 598 | def infer_indent_level(line); end 599 | def initialize(lexer, str_type, delimiter, str_s, heredoc_e = nil, indent = nil, dedent_body = nil, label_allowed = nil); end 600 | def interpolate?; end 601 | def munge_escape?(character); end 602 | def nest_and_try_closing(delimiter, ts, te, lookahead = nil); end 603 | def plain_heredoc?; end 604 | def regexp?; end 605 | def saved_herebody_s; end 606 | def saved_herebody_s=(arg0); end 607 | def squiggly_heredoc?; end 608 | def start_interp_brace; end 609 | def str_s; end 610 | def supports_line_continuation_via_slash?; end 611 | def type; end 612 | def words?; end 613 | end 614 | class Parser::Lexer::StackState 615 | def active?; end 616 | def clear; end 617 | def empty?; end 618 | def initialize(name); end 619 | def inspect; end 620 | def lexpop; end 621 | def pop; end 622 | def push(bit); end 623 | def to_s; end 624 | end 625 | class Parser::Lexer::Dedenter 626 | def dedent(string); end 627 | def initialize(dedent_level); end 628 | def interrupt; end 629 | end 630 | class Parser::Builders::Default 631 | def __ENCODING__(__ENCODING__t); end 632 | def __FILE__(__FILE__t); end 633 | def __LINE__(__LINE__t); end 634 | def accessible(node); end 635 | def alias(alias_t, to, from); end 636 | def arg(name_t); end 637 | def arg_expr(expr); end 638 | def arg_name_collides?(this_name, that_name); end 639 | def arg_prefix_map(op_t, name_t = nil); end 640 | def args(begin_t, args, end_t, check_args = nil); end 641 | def array(begin_t, elements, end_t); end 642 | def array_pattern(lbrack_t, elements, rbrack_t); end 643 | def assign(lhs, eql_t, rhs); end 644 | def assignable(node); end 645 | def associate(begin_t, pairs, end_t); end 646 | def attr_asgn(receiver, dot_t, selector_t); end 647 | def back_ref(token); end 648 | def begin(begin_t, body, end_t); end 649 | def begin_body(compound_stmt, rescue_bodies = nil, else_t = nil, else_ = nil, ensure_t = nil, ensure_ = nil); end 650 | def begin_keyword(begin_t, body, end_t); end 651 | def binary_op(receiver, operator_t, arg); end 652 | def binary_op_map(left_e, op_t, right_e); end 653 | def block(method_call, begin_t, args, body, end_t); end 654 | def block_map(receiver_l, begin_t, end_t); end 655 | def block_pass(amper_t, arg); end 656 | def blockarg(amper_t, name_t); end 657 | def blockarg_expr(amper_t, expr); end 658 | def call_lambda(lambda_t); end 659 | def call_method(receiver, dot_t, selector_t, lparen_t = nil, args = nil, rparen_t = nil); end 660 | def call_type_for_dot(dot_t); end 661 | def case(case_t, expr, when_bodies, else_t, else_body, end_t); end 662 | def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end 663 | def character(char_t); end 664 | def check_assignment_to_numparam(node); end 665 | def check_condition(cond); end 666 | def check_duplicate_arg(this_arg, map = nil); end 667 | def check_duplicate_args(args, map = nil); end 668 | def check_duplicate_pattern_key(name, loc); end 669 | def check_duplicate_pattern_variable(name, loc); end 670 | def check_lvar_name(name, loc); end 671 | def collapse_string_parts?(parts); end 672 | def collection_map(begin_t, parts, end_t); end 673 | def complex(complex_t); end 674 | def compstmt(statements); end 675 | def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end 676 | def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end 677 | def condition_mod(if_true, if_false, cond_t, cond); end 678 | def const(name_t); end 679 | def const_fetch(scope, t_colon2, name_t); end 680 | def const_global(t_colon3, name_t); end 681 | def const_op_assignable(node); end 682 | def const_pattern(const, ldelim_t, pattern, rdelim_t); end 683 | def constant_map(scope, colon2_t, name_t); end 684 | def cvar(token); end 685 | def dedent_string(node, dedent_level); end 686 | def def_class(class_t, name, lt_t, superclass, body, end_t); end 687 | def def_method(def_t, name_t, args, body, end_t); end 688 | def def_module(module_t, name, body, end_t); end 689 | def def_sclass(class_t, lshft_t, expr, body, end_t); end 690 | def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end 691 | def definition_map(keyword_t, operator_t, name_t, end_t); end 692 | def delimited_string_map(string_t); end 693 | def diagnostic(type, reason, arguments, location, highlights = nil); end 694 | def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end 695 | def emit_file_line_as_literals; end 696 | def emit_file_line_as_literals=(arg0); end 697 | def expr_map(loc); end 698 | def false(false_t); end 699 | def float(float_t); end 700 | def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end 701 | def for_map(keyword_t, in_t, begin_t, end_t); end 702 | def forward_args(begin_t, dots_t, end_t); end 703 | def forwarded_args(dots_t); end 704 | def guard_map(keyword_t, guard_body_e); end 705 | def gvar(token); end 706 | def hash_pattern(lbrace_t, kwargs, rbrace_t); end 707 | def ident(token); end 708 | def if_guard(if_t, if_body); end 709 | def in_match(lhs, in_t, rhs); end 710 | def in_pattern(in_t, pattern, guard, then_t, body); end 711 | def index(receiver, lbrack_t, indexes, rbrack_t); end 712 | def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end 713 | def index_map(receiver_e, lbrack_t, rbrack_t); end 714 | def initialize; end 715 | def integer(integer_t); end 716 | def ivar(token); end 717 | def join_exprs(left_expr, right_expr); end 718 | def keyword_cmd(type, keyword_t, lparen_t = nil, args = nil, rparen_t = nil); end 719 | def keyword_map(keyword_t, begin_t, args, end_t); end 720 | def keyword_mod_map(pre_e, keyword_t, post_e); end 721 | def kwarg(name_t); end 722 | def kwarg_map(name_t, value_e = nil); end 723 | def kwnilarg(dstar_t, nil_t); end 724 | def kwoptarg(name_t, value); end 725 | def kwrestarg(dstar_t, name_t = nil); end 726 | def kwsplat(dstar_t, arg); end 727 | def loc(token); end 728 | def logical_op(type, lhs, op_t, rhs); end 729 | def loop(type, keyword_t, cond, do_t, body, end_t); end 730 | def loop_mod(type, body, keyword_t, cond); end 731 | def match_alt(left, pipe_t, right); end 732 | def match_as(value, assoc_t, as); end 733 | def match_hash_var(name_t); end 734 | def match_hash_var_from_str(begin_t, strings, end_t); end 735 | def match_label(label_type, label); end 736 | def match_nil_pattern(dstar_t, nil_t); end 737 | def match_op(receiver, match_t, arg); end 738 | def match_pair(label_type, label, value); end 739 | def match_rest(star_t, name_t = nil); end 740 | def match_var(name_t); end 741 | def match_with_trailing_comma(match); end 742 | def module_definition_map(keyword_t, name_e, operator_t, end_t); end 743 | def multi_assign(lhs, eql_t, rhs); end 744 | def multi_lhs(begin_t, items, end_t); end 745 | def n(type, children, source_map); end 746 | def n0(type, source_map); end 747 | def nil(nil_t); end 748 | def not_op(not_t, begin_t = nil, receiver = nil, end_t = nil); end 749 | def nth_ref(token); end 750 | def numargs(max_numparam); end 751 | def numeric(kind, token); end 752 | def objc_kwarg(kwname_t, assoc_t, name_t); end 753 | def objc_restarg(star_t, name = nil); end 754 | def objc_varargs(pair, rest_of_varargs); end 755 | def op_assign(lhs, op_t, rhs); end 756 | def optarg(name_t, eql_t, value); end 757 | def pair(key, assoc_t, value); end 758 | def pair_keyword(key_t, value); end 759 | def pair_keyword_map(key_t, value_e); end 760 | def pair_list_18(list); end 761 | def pair_quoted(begin_t, parts, end_t, value); end 762 | def pair_quoted_map(begin_t, end_t, value_e); end 763 | def parser; end 764 | def parser=(arg0); end 765 | def pin(pin_t, var); end 766 | def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end 767 | def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end 768 | def prefix_string_map(symbol); end 769 | def procarg0(arg); end 770 | def range_exclusive(lhs, dot3_t, rhs); end 771 | def range_inclusive(lhs, dot2_t, rhs); end 772 | def range_map(start_e, op_t, end_e); end 773 | def rational(rational_t); end 774 | def regexp_compose(begin_t, parts, end_t, options); end 775 | def regexp_map(begin_t, end_t, options_e); end 776 | def regexp_options(regopt_t); end 777 | def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end 778 | def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end 779 | def restarg(star_t, name_t = nil); end 780 | def restarg_expr(star_t, expr = nil); end 781 | def self(token); end 782 | def self.emit_arg_inside_procarg0; end 783 | def self.emit_arg_inside_procarg0=(arg0); end 784 | def self.emit_encoding; end 785 | def self.emit_encoding=(arg0); end 786 | def self.emit_index; end 787 | def self.emit_index=(arg0); end 788 | def self.emit_lambda; end 789 | def self.emit_lambda=(arg0); end 790 | def self.emit_procarg0; end 791 | def self.emit_procarg0=(arg0); end 792 | def self.modernize; end 793 | def send_binary_op_map(lhs_e, selector_t, rhs_e); end 794 | def send_index_map(receiver_e, lbrack_t, rbrack_t); end 795 | def send_map(receiver_e, dot_t, selector_t, begin_t = nil, args = nil, end_t = nil); end 796 | def send_unary_op_map(selector_t, arg_e); end 797 | def shadowarg(name_t); end 798 | def splat(star_t, arg = nil); end 799 | def static_regexp(parts, options); end 800 | def static_regexp_node(node); end 801 | def static_string(nodes); end 802 | def string(string_t); end 803 | def string_compose(begin_t, parts, end_t); end 804 | def string_internal(string_t); end 805 | def string_map(begin_t, parts, end_t); end 806 | def string_value(token); end 807 | def symbol(symbol_t); end 808 | def symbol_compose(begin_t, parts, end_t); end 809 | def symbol_internal(symbol_t); end 810 | def symbols_compose(begin_t, parts, end_t); end 811 | def ternary(cond, question_t, if_true, colon_t, if_false); end 812 | def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end 813 | def token_map(token); end 814 | def true(true_t); end 815 | def unary_num(unary_t, numeric); end 816 | def unary_op(op_t, receiver); end 817 | def unary_op_map(op_t, arg_e = nil); end 818 | def undef_method(undef_t, names); end 819 | def unless_guard(unless_t, unless_body); end 820 | def unquoted_map(token); end 821 | def value(token); end 822 | def var_send_map(variable_e); end 823 | def variable_map(name_t); end 824 | def when(when_t, patterns, then_t, body); end 825 | def word(parts); end 826 | def words_compose(begin_t, parts, end_t); end 827 | def xstring_compose(begin_t, parts, end_t); end 828 | end 829 | class Parser::Context 830 | def class_definition_allowed?; end 831 | def dynamic_const_definition_allowed?; end 832 | def in_block?; end 833 | def in_class?; end 834 | def in_dynamic_block?; end 835 | def in_lambda?; end 836 | def indirectly_in_def?; end 837 | def initialize; end 838 | def module_definition_allowed?; end 839 | def pop; end 840 | def push(state); end 841 | def reset; end 842 | def stack; end 843 | end 844 | class Parser::MaxNumparamStack 845 | def has_numparams?; end 846 | def has_ordinary_params!; end 847 | def has_ordinary_params?; end 848 | def initialize; end 849 | def pop; end 850 | def push; end 851 | def register(numparam); end 852 | def set(value); end 853 | def stack; end 854 | def top; end 855 | end 856 | class Parser::CurrentArgStack 857 | def initialize; end 858 | def pop; end 859 | def push(value); end 860 | def reset; end 861 | def set(value); end 862 | def stack; end 863 | def top; end 864 | end 865 | class Parser::VariablesStack 866 | def declare(name); end 867 | def declared?(name); end 868 | def initialize; end 869 | def pop; end 870 | def push; end 871 | def reset; end 872 | end 873 | class Parser::Base < Racc::Parser 874 | def builder; end 875 | def check_kwarg_name(name_t); end 876 | def context; end 877 | def current_arg_stack; end 878 | def diagnostic(level, reason, arguments, location_t, highlights_ts = nil); end 879 | def diagnostics; end 880 | def initialize(builder = nil); end 881 | def max_numparam_stack; end 882 | def next_token; end 883 | def on_error(error_token_id, error_value, value_stack); end 884 | def parse(source_buffer); end 885 | def parse_with_comments(source_buffer); end 886 | def pattern_hash_keys; end 887 | def pattern_variables; end 888 | def reset; end 889 | def self.default_parser; end 890 | def self.parse(string, file = nil, line = nil); end 891 | def self.parse_file(filename); end 892 | def self.parse_file_with_comments(filename); end 893 | def self.parse_with_comments(string, file = nil, line = nil); end 894 | def self.setup_source_buffer(file, line, string, encoding); end 895 | def source_buffer; end 896 | def static_env; end 897 | def tokenize(source_buffer, recover = nil); end 898 | end 899 | class Parser::Rewriter < Parser::AST::Processor 900 | def assignment?(node); end 901 | def initialize(*arg0); end 902 | def insert_after(range, content); end 903 | def insert_before(range, content); end 904 | def remove(range); end 905 | def replace(range, content); end 906 | def rewrite(source_buffer, ast); end 907 | def wrap(range, before, after); end 908 | extend Parser::Deprecation 909 | end 910 | class Parser::TreeRewriter < Parser::AST::Processor 911 | def assignment?(node); end 912 | def insert_after(range, content); end 913 | def insert_before(range, content); end 914 | def remove(range); end 915 | def replace(range, content); end 916 | def rewrite(source_buffer, ast, **policy); end 917 | def wrap(range, before, after); end 918 | end 919 | module Parser::Builders 920 | end 921 | --------------------------------------------------------------------------------