sorbet-struct-comparable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cdc3f402081351e1da4c84bc5dc767f59d288b781763ba64be2b1f4e6d77768
+  data.tar.gz: c336b74f657fb64e7b29e024ceb10c02e555a82f89283f758e9984aeb6c65b5e
+SHA512:
+  metadata.gz: a505ab5eed81e5f80280e6c7f2ae68c619d561c2c4ef13ec0866249083e7092ada08d961502d4d7fdb7f289a07849fdf044eb58121e2bd8c2a802c12c8f14121
+  data.tar.gz: f3958b00820ff24401823af78c8b91d789fd2da090e117c15699a0a1bbb125f1770c1b1eaa32111650a8fae319ee1e3232052da12cbebf89c3cd136c754ae670

data/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+---
+    name: Continuous Integration
+    on:
+      push:
+        branches-ignore:
+        - refs/tags/*_staging
+        - refs/tags/*_production
+    jobs:
+      build:
+        runs-on: ubuntu-18.04
+        steps:
+        - name: Checkout branch
+          uses: actions/checkout@v2
+        - name: Extract branch name
+          shell: bash
+          run: echo "##[set-output name=branch;]$(echo ${GITHUB_REF#refs/heads/})"
+          id: extract_branch
+        - name: Set up Ruby
+          uses: actions/setup-ruby@v1.1.1
+          with:
+            ruby-version: 2.7.1
+        - name: Cache gems
+          uses: actions/cache@v1
+          with:
+            path: vendor/bundle
+            key: "${{ runner.OS }}-gem-cache-${{ hashFiles('**/sorbet-struct-comparable.gemspec')
+              }}"
+            restore-keys: "${{ runner.OS }}-gem-cache-\n"
+        - name: Install bundler
+          run: (bundler -v | grep "2.1.4") || gem install bundler:2.1.4
+        - name: Install gems
+          run: bundle install --jobs $(nproc) --retry 3 --without metrics --path vendor/bundle
+        - name: Create cache directory
+          run: mkdir -p tmp/cache
+        - name: Typecheck with Sorbet
+          run: bundle exec srb tc . --ignore=/vendor
+        - name: Run RSpec test suite
+          run: bundle exec rspec spec
+          env:
+            METRICS: '1'
+        - name: Post to Slack if build fails
+          if: failure() && (github.ref == 'refs/heads/master' || github.ref == 'refs/heads/stable')
+          uses: pullreminders/slack-action@master
+          env:
+            SLACK_BOT_TOKEN: "${{ secrets.SLACK_BOT_TOKEN }}"
+          with:
+            args: '{\"channel\":\"C33574SJJ\",\"text\":\"* ${{ github.repository }} BUILD
+              FAILURE*\", \"attachments\": [{ \"fallback\": \"Failure summary\", \"color\":
+              \"#ff0000\", \"fields\": [{\"title\": \"Branch\", \"value\":\"${{ steps.extract_branch.outputs.branch
+              }}\"}, {\"title\": \"Who broke it\", \"value\":\"${{ github.actor }}\"},
+              { \"title\": \"Build output\", \"value\": \"https://github.com/${{ github.repository
+              }}/commit/${{ github.sha }}/checks\", \"short\": false }]}]}'

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+2.7.1

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Releases
+
+1.0.0
+
+* Initial release: Extracted from [https://bellroy.com/](Bellroy) projects.

data/Gemfile

@@ -0,0 +1,22 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sorbet-struct-comparable.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rake', '~> 12.0'
+  gem 'rspec', '~> 3.0'
+  gem 'pry-byebug'
+  gem 'sorbet'
+  gem 'sorbet-runtime'
+end
+
+group :development do
+  gem 'spring'
+  gem 'spring-watcher-listen'
+end
+
+group :test do
+  gem 'simplecov'
+  gem 'spring-commands-rspec'
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Bellroy Tech
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,70 @@
+![Sorbet](https://user-images.githubusercontent.com/2643026/84757714-60be0600-afbc-11ea-8c0e-7da839ea1712.png)
+
+![Continuous Integration](https://github.com/tricycle/sorbet-struct-comparable/workflows/Continuous%20Integration/badge.svg)
+# Making T::Struct's comparable since 2020
+
+If you just want some simple equality checking on your `T::Struct`'s then you've come to the right place.
+
+Out of the box Sorbet's super useful `T::Struct`'s (<https://sorbet.org/docs/tstruct>) are not comparable meaning two separate instances (i.e. different `#object_id`'s) of a `T::Struct` with identical attributes are not equal.
+
+This behaviour can be confusing at first glance, especially if/when you start using `T::Struct`'s alongside RSpec where expectations such as `it { is_expected.to eq my_expected_struct }` will fail.
+
+It makes sense for this comparable behaviour to not be baked into `T::Struct`'s by default since defining what makes two instances of something equal could be seen by some as business logic, but for the 90% of cases where you just want to run `<=>` over your attributes this mixin is a solution.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sorbet-struct-comparable'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install sorbet-struct-comparable
+
+## Usage
+
+Just include `T::Struct::ActsAsComparable` in your struct, done!
+
+```ruby
+require 'sorbet-struct-comparable'
+
+class BlogPost < T::Struct
+  include T::Struct::ActsAsComparable
+
+  class Topic < T::Enum
+    enums do
+      Cycling = new
+      Music = new
+      Walking = new
+    end
+  end
+
+  const :title, String
+  const :topic, Topic
+end
+
+blog_post = BlogPost.new(title: 'My Blog Post', topic: BlogPost::Topic::Cycling)
+different_blog_post = BlogPost.new(title: 'Another Blog Post', topic: BlogPost::Topic::Walking)
+identical_blog_post = BlogPost.new(title: 'My Blog Post', topic: BlogPost::Topic::Cycling)
+
+blog_post == different_blog_post
+# => false
+blog_post == identical_blog_post
+# => true
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tricycle/sorbet-struct-comparable.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'sorbet-struct-comparable'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/sorbet-struct-comparable.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'sorbet-struct-comparable/version'
+require 't/struct/acts_as_comparable'

data/lib/sorbet-struct-comparable/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module SorbetStructComparable
+  VERSION = '1.0.0'
+end

data/lib/t/struct/acts_as_comparable.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module T
+  class Struct
+    module ActsAsComparable
+      extend T::Sig
+      include ::Comparable
+
+      LESS_THAN_OTHER = -1
+      EQUAL = 0
+
+      sig { params(other: Object).returns(Integer) }
+      def <=>(other)
+        result = EQUAL
+        return LESS_THAN_OTHER if other.class != T.unsafe(self).class
+
+        T.unsafe(self).class.decorator.props.keys.map do |attribute_key|
+          compare_result = T.unsafe(self).send(attribute_key) <=> other.send(attribute_key)
+          result = if compare_result.nil?
+                    LESS_THAN_OTHER
+                   else
+                     T.cast(compare_result, Integer)
+                   end
+          break if result != EQUAL
+        end
+        result
+      end
+    end
+  end
+end

data/sorbet-struct-comparable.gemspec

@@ -0,0 +1,32 @@
+require_relative 'lib/sorbet-struct-comparable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'sorbet-struct-comparable'
+  spec.version       = SorbetStructComparable::VERSION
+  spec.authors       = ['Bellroy Tech Team']
+  spec.email         = ['michael.webb@bellroy.com', 'sam@samuelgil.es']
+
+  spec.summary       = "Comparable T::Struct's for the equality focused typed Ruby developer."
+  spec.homepage      = 'https://github.com/tricycle/sorbet-struct-comparable'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.0.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/master/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sorbet-runtime', '>= 0.5'
+
+  spec.add_development_dependency 'bundler', '>= 1.13'
+  spec.add_development_dependency 'rake', '>= 10.0'
+  spec.add_development_dependency 'rspec', '>= 3.0'
+  spec.add_development_dependency 'sorbet', '>= 0.5'
+end

data/sorbet/config

@@ -0,0 +1,2 @@
+--dir
+.

data/sorbet/rbi/gems/byebug.rbi

@@ -0,0 +1,1041 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/byebug/all/byebug.rbi
+#
+# byebug-11.1.3
+
+module Byebug
+  def add_catchpoint(arg0); end
+  def breakpoints; end
+  def catchpoints; end
+  def contexts; end
+  def current_context; end
+  def debug_load(*arg0); end
+  def displays; end
+  def displays=(arg0); end
+  def init_file; end
+  def init_file=(arg0); end
+  def lock; end
+  def mode; end
+  def mode=(arg0); end
+  def post_mortem=(arg0); end
+  def post_mortem?; end
+  def raised_exception; end
+  def rc_dirs; end
+  def run_init_script; end
+  def run_rc_file(rc_file); end
+  def self.actual_control_port; end
+  def self.actual_port; end
+  def self.add_catchpoint(arg0); end
+  def self.attach; end
+  def self.breakpoints; end
+  def self.catchpoints; end
+  def self.client; end
+  def self.contexts; end
+  def self.control; end
+  def self.current_context; end
+  def self.debug_load(*arg0); end
+  def self.handle_post_mortem; end
+  def self.interrupt; end
+  def self.load_settings; end
+  def self.lock; end
+  def self.parse_host_and_port(host_port_spec); end
+  def self.post_mortem=(arg0); end
+  def self.post_mortem?; end
+  def self.raised_exception; end
+  def self.server; end
+  def self.spawn(host = nil, port = nil); end
+  def self.start; end
+  def self.start_client(host = nil, port = nil); end
+  def self.start_control(host = nil, port = nil); end
+  def self.start_server(host = nil, port = nil); end
+  def self.started?; end
+  def self.stop; end
+  def self.stoppable?; end
+  def self.thread_context(arg0); end
+  def self.tracing=(arg0); end
+  def self.tracing?; end
+  def self.unlock; end
+  def self.verbose=(arg0); end
+  def self.verbose?; end
+  def self.wait_connection; end
+  def self.wait_connection=(arg0); end
+  def start; end
+  def started?; end
+  def stop; end
+  def stoppable?; end
+  def thread_context(arg0); end
+  def tracing=(arg0); end
+  def tracing?; end
+  def unlock; end
+  def verbose=(arg0); end
+  def verbose?; end
+  extend Byebug
+  include Byebug::Helpers::ReflectionHelper
+end
+module Kernel
+  def byebug; end
+  def debugger; end
+  def remote_byebug(host = nil, port = nil); end
+end
+module Byebug::Helpers
+end
+module Byebug::Helpers::ReflectionHelper
+  def commands; end
+end
+class Byebug::Context
+  def at_breakpoint(breakpoint); end
+  def at_catchpoint(exception); end
+  def at_end; end
+  def at_line; end
+  def at_return(return_value); end
+  def at_tracing; end
+  def backtrace; end
+  def dead?; end
+  def file(*args, &block); end
+  def frame; end
+  def frame=(pos); end
+  def frame_binding(*arg0); end
+  def frame_class(*arg0); end
+  def frame_file(*arg0); end
+  def frame_line(*arg0); end
+  def frame_method(*arg0); end
+  def frame_self(*arg0); end
+  def full_location; end
+  def ignored?; end
+  def ignored_file?(path); end
+  def interrupt; end
+  def line(*args, &block); end
+  def location; end
+  def processor; end
+  def resume; end
+  def self.ignored_files; end
+  def self.ignored_files=(arg0); end
+  def self.interface; end
+  def self.interface=(arg0); end
+  def self.processor; end
+  def self.processor=(arg0); end
+  def stack_size; end
+  def step_into(*arg0); end
+  def step_out(*arg0); end
+  def step_over(*arg0); end
+  def stop_reason; end
+  def suspend; end
+  def suspended?; end
+  def switch; end
+  def thnum; end
+  def thread; end
+  def tracing; end
+  def tracing=(arg0); end
+  extend Forwardable
+  include Byebug::Helpers::FileHelper
+end
+class Byebug::DebugThread < Thread
+  def self.inherited; end
+end
+class Byebug::Breakpoint
+  def enabled=(arg0); end
+  def enabled?; end
+  def expr; end
+  def expr=(arg0); end
+  def hit_condition; end
+  def hit_condition=(arg0); end
+  def hit_count; end
+  def hit_value; end
+  def hit_value=(arg0); end
+  def id; end
+  def initialize(arg0, arg1, arg2); end
+  def inspect; end
+  def pos; end
+  def self.add(file, line, expr = nil); end
+  def self.first; end
+  def self.last; end
+  def self.none?; end
+  def self.potential_line?(filename, lineno); end
+  def self.potential_lines(filename); end
+  def self.potential_lines_with_trace_points(iseq, lines); end
+  def self.potential_lines_without_trace_points(iseq, lines); end
+  def self.remove(id); end
+  def source; end
+end
+module Byebug::Helpers::FileHelper
+  def get_line(filename, lineno); end
+  def get_lines(filename); end
+  def n_lines(filename); end
+  def normalize(filename); end
+  def shortpath(fullpath); end
+  def virtual_file?(name); end
+end
+class Byebug::Frame
+  def _binding; end
+  def _class; end
+  def _method; end
+  def _self; end
+  def args; end
+  def c_args; end
+  def c_frame?; end
+  def current?; end
+  def deco_args; end
+  def deco_block; end
+  def deco_call; end
+  def deco_class; end
+  def deco_file; end
+  def deco_method; end
+  def deco_pos; end
+  def file; end
+  def initialize(context, pos); end
+  def line; end
+  def locals; end
+  def mark; end
+  def pos; end
+  def prefix_and_default(arg_type); end
+  def ruby_args; end
+  def to_hash; end
+  def use_short_style?(arg); end
+  include Byebug::Helpers::FileHelper
+end
+module Byebug::Helpers::PathHelper
+  def all_files; end
+  def bin_file; end
+  def gem_files; end
+  def glob_for(dir); end
+  def lib_files; end
+  def root_path; end
+  def test_files; end
+end
+module Byebug::Helpers::EvalHelper
+  def allowing_other_threads; end
+  def error_eval(str, binding = nil); end
+  def error_msg(exception); end
+  def in_new_thread; end
+  def msg(exception); end
+  def multiple_thread_eval(expression); end
+  def safe_eval(str, binding); end
+  def safe_inspect(var); end
+  def safe_to_s(var); end
+  def separate_thread_eval(expression); end
+  def silent_eval(str, binding = nil); end
+  def warning_eval(str, binding = nil); end
+  def warning_msg(exception); end
+end
+class Byebug::CommandNotFound < NoMethodError
+  def build_cmd(*args); end
+  def help; end
+  def initialize(input, parent = nil); end
+  def name; end
+end
+class Byebug::CommandProcessor
+  def after_repl; end
+  def at_breakpoint(brkpt); end
+  def at_catchpoint(exception); end
+  def at_end; end
+  def at_line; end
+  def at_return(return_value); end
+  def at_tracing; end
+  def auto_cmds_for(run_level); end
+  def before_repl; end
+  def command_list; end
+  def commands(*args, &block); end
+  def confirm(*args, &block); end
+  def context; end
+  def errmsg(*args, &block); end
+  def frame(*args, &block); end
+  def initialize(context, interface = nil); end
+  def interface; end
+  def pr(*args, &block); end
+  def prc(*args, &block); end
+  def prev_line; end
+  def prev_line=(arg0); end
+  def printer; end
+  def proceed!; end
+  def process_commands; end
+  def prompt; end
+  def prv(*args, &block); end
+  def puts(*args, &block); end
+  def repl; end
+  def run_auto_cmds(run_level); end
+  def run_cmd(input); end
+  def safely; end
+  extend Forwardable
+  include Byebug::Helpers::EvalHelper
+end
+module Byebug::Helpers::StringHelper
+  def camelize(str); end
+  def deindent(str, leading_spaces: nil); end
+  def prettify(str); end
+end
+class Byebug::Setting
+  def boolean?; end
+  def help; end
+  def initialize; end
+  def integer?; end
+  def self.[](name); end
+  def self.[]=(name, value); end
+  def self.find(shortcut); end
+  def self.help_all; end
+  def self.settings; end
+  def to_s; end
+  def to_sym; end
+  def value; end
+  def value=(arg0); end
+end
+class Byebug::History
+  def buffer; end
+  def clear; end
+  def default_max_size; end
+  def ignore?(buf); end
+  def initialize; end
+  def last_ids(number); end
+  def pop; end
+  def push(cmd); end
+  def restore; end
+  def save; end
+  def size; end
+  def size=(arg0); end
+  def specific_max_size(number); end
+  def to_s(n_cmds); end
+end
+class Byebug::LocalInterface < Byebug::Interface
+  def initialize; end
+  def readline(prompt); end
+  def with_repl_like_sigint; end
+  def without_readline_completion; end
+end
+class Byebug::ScriptInterface < Byebug::Interface
+  def close; end
+  def initialize(file, verbose = nil); end
+  def read_command(prompt); end
+  def readline(*arg0); end
+end
+class Byebug::RemoteInterface < Byebug::Interface
+  def close; end
+  def confirm(prompt); end
+  def initialize(socket); end
+  def print(message); end
+  def puts(message); end
+  def read_command(prompt); end
+  def readline(prompt); end
+end
+class Byebug::Interface
+  def autorestore; end
+  def autosave; end
+  def close; end
+  def command_queue; end
+  def command_queue=(arg0); end
+  def confirm(prompt); end
+  def errmsg(message); end
+  def error; end
+  def history; end
+  def history=(arg0); end
+  def initialize; end
+  def input; end
+  def last_if_empty(input); end
+  def output; end
+  def prepare_input(prompt); end
+  def print(message); end
+  def puts(message); end
+  def read_command(prompt); end
+  def read_file(filename); end
+  def read_input(prompt, save_hist = nil); end
+  def split_commands(cmd_line); end
+  include Byebug::Helpers::FileHelper
+end
+class Byebug::ScriptProcessor < Byebug::CommandProcessor
+  def after_repl; end
+  def commands; end
+  def prompt; end
+  def repl; end
+  def without_exceptions; end
+end
+class Byebug::PostMortemProcessor < Byebug::CommandProcessor
+  def commands; end
+  def prompt; end
+end
+class Byebug::Command
+  def arguments; end
+  def confirm(*args, &block); end
+  def context; end
+  def errmsg(*args, &block); end
+  def frame; end
+  def help(*args, &block); end
+  def initialize(processor, input = nil); end
+  def match(*args, &block); end
+  def pr(*args, &block); end
+  def prc(*args, &block); end
+  def print(*args, &block); end
+  def processor; end
+  def prv(*args, &block); end
+  def puts(*args, &block); end
+  def self.allow_in_control; end
+  def self.allow_in_control=(arg0); end
+  def self.allow_in_post_mortem; end
+  def self.allow_in_post_mortem=(arg0); end
+  def self.always_run; end
+  def self.always_run=(arg0); end
+  def self.columnize(width); end
+  def self.help; end
+  def self.match(input); end
+  def self.to_s; end
+  extend Forwardable
+end
+module Byebug::Helpers::ParseHelper
+  def get_int(str, cmd, min = nil, max = nil); end
+  def parse_steps(str, cmd); end
+  def syntax_valid?(code); end
+  def without_stderr; end
+end
+class Byebug::SourceFileFormatter
+  def amend(line, ceiling); end
+  def amend_final(line); end
+  def amend_initial(line); end
+  def annotator; end
+  def file; end
+  def initialize(file, annotator); end
+  def lines(min, max); end
+  def lines_around(center); end
+  def max_initial_line; end
+  def max_line; end
+  def range_around(center); end
+  def range_from(min); end
+  def size; end
+  include Byebug::Helpers::FileHelper
+end
+class Byebug::BreakCommand < Byebug::Command
+  def add_line_breakpoint(file, line); end
+  def execute; end
+  def line_breakpoint(location); end
+  def method_breakpoint(location); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def target_object(str); end
+  def valid_breakpoints_for(path, line); end
+  include Byebug::Helpers::EvalHelper
+  include Byebug::Helpers::FileHelper
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::CatchCommand < Byebug::Command
+  def add(exception); end
+  def clear; end
+  def execute; end
+  def info; end
+  def remove(exception); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::EvalHelper
+end
+class Byebug::ConditionCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::ContinueCommand < Byebug::Command
+  def execute; end
+  def modifier; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def unconditionally?; end
+  def until_line?; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::DebugCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::EvalHelper
+end
+class Byebug::DeleteCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::CommandList
+  def each; end
+  def initialize(commands); end
+  def match(input); end
+  def to_s; end
+  def width; end
+  include Enumerable
+end
+module Byebug::Subcommands
+  def execute; end
+  def self.included(command); end
+  def subcommand_list(*args, &block); end
+  extend Forwardable
+end
+module Byebug::Subcommands::ClassMethods
+  def help; end
+  def subcommand_list; end
+  include Byebug::Helpers::ReflectionHelper
+end
+module Byebug::Helpers::ToggleHelper
+  def enable_disable_breakpoints(is_enable, args); end
+  def enable_disable_display(is_enable, args); end
+  def n_displays; end
+  def select_breakpoints(is_enable, args); end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::DisableCommand < Byebug::Command
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  extend Byebug::Subcommands::ClassMethods
+  include Byebug::Subcommands
+end
+class Byebug::DisableCommand::BreakpointsCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ToggleHelper
+end
+class Byebug::DisableCommand::DisplayCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ToggleHelper
+end
+class Byebug::DisplayCommand < Byebug::Command
+  def display_expression(exp); end
+  def eval_expr(expression); end
+  def execute; end
+  def print_display_expressions; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::EvalHelper
+end
+module Byebug::Helpers::FrameHelper
+  def adjust_frame(new_frame); end
+  def direction(step); end
+  def frame_err(msg); end
+  def index_from_start(index); end
+  def jump_frames(steps); end
+  def navigate_to_frame(jump_no); end
+  def out_of_bounds?(pos); end
+  def switch_to_frame(frame); end
+end
+class Byebug::DownCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::FrameHelper
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::EditCommand < Byebug::Command
+  def edit_error(type, file); end
+  def editor; end
+  def execute; end
+  def location(matched); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::EnableCommand < Byebug::Command
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  extend Byebug::Subcommands::ClassMethods
+  include Byebug::Subcommands
+end
+class Byebug::EnableCommand::BreakpointsCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ToggleHelper
+end
+class Byebug::EnableCommand::DisplayCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ToggleHelper
+end
+class Byebug::FinishCommand < Byebug::Command
+  def execute; end
+  def max_frames; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::FrameCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::FrameHelper
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::HelpCommand < Byebug::Command
+  def command; end
+  def execute; end
+  def help_for(input, cmd); end
+  def help_for_all; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def subcommand; end
+end
+class Byebug::HistoryCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::InfoCommand < Byebug::Command
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  extend Byebug::Subcommands::ClassMethods
+  include Byebug::Subcommands
+end
+class Byebug::InfoCommand::BreakpointsCommand < Byebug::Command
+  def execute; end
+  def info_breakpoint(brkpt); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::InfoCommand::DisplayCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::InfoCommand::FileCommand < Byebug::Command
+  def execute; end
+  def info_file_basic(file); end
+  def info_file_breakpoints(file); end
+  def info_file_mtime(file); end
+  def info_file_sha1(file); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::FileHelper
+  include Byebug::Helpers::StringHelper
+end
+class Byebug::InfoCommand::LineCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::InfoCommand::ProgramCommand < Byebug::Command
+  def execute; end
+  def format_stop_reason(stop_reason); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::InterruptCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::IrbCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def with_clean_argv; end
+end
+class Byebug::KillCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::ListCommand < Byebug::Command
+  def amend_final(*args, &block); end
+  def auto_range(direction); end
+  def display_lines(min, max); end
+  def execute; end
+  def lower_bound(range); end
+  def max_line(*args, &block); end
+  def move(line, size, direction = nil); end
+  def parse_range(input); end
+  def range(input); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def size(*args, &block); end
+  def source_file_formatter; end
+  def split_range(str); end
+  def upper_bound(range); end
+  def valid_range?(first, last); end
+  extend Forwardable
+  include Byebug::Helpers::FileHelper
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::MethodCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::EvalHelper
+end
+class Byebug::NextCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::PryCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::QuitCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+module Byebug::Helpers::BinHelper
+  def executable_file_extensions; end
+  def find_executable(path, cmd); end
+  def real_executable?(file); end
+  def search_paths; end
+  def which(cmd); end
+end
+class Byebug::RestartCommand < Byebug::Command
+  def execute; end
+  def prepend_byebug_bin(cmd); end
+  def prepend_ruby_bin(cmd); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::BinHelper
+  include Byebug::Helpers::PathHelper
+end
+class Byebug::SaveCommand < Byebug::Command
+  def execute; end
+  def save_breakpoints(file); end
+  def save_catchpoints(file); end
+  def save_displays(file); end
+  def save_settings(file); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::SetCommand < Byebug::Command
+  def execute; end
+  def get_onoff(arg, default); end
+  def self.description; end
+  def self.help; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::ShowCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.help; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::SkipCommand < Byebug::Command
+  def auto_run; end
+  def execute; end
+  def initialize_attributes; end
+  def keep_execution; end
+  def reset_attributes; end
+  def self.description; end
+  def self.file_line; end
+  def self.file_line=(arg0); end
+  def self.file_path; end
+  def self.file_path=(arg0); end
+  def self.previous_autolist; end
+  def self.regexp; end
+  def self.restore_autolist; end
+  def self.setup_autolist(value); end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::SourceCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::StepCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+module Byebug::Helpers::ThreadHelper
+  def context_from_thread(thnum); end
+  def current_thread?(ctx); end
+  def debug_flag(ctx); end
+  def display_context(ctx); end
+  def location(ctx); end
+  def status_flag(ctx); end
+  def thread_arguments(ctx); end
+end
+class Byebug::ThreadCommand < Byebug::Command
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  extend Byebug::Subcommands::ClassMethods
+  include Byebug::Subcommands
+end
+class Byebug::ThreadCommand::CurrentCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ThreadHelper
+end
+class Byebug::ThreadCommand::ListCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ThreadHelper
+end
+class Byebug::ThreadCommand::ResumeCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ThreadHelper
+end
+class Byebug::ThreadCommand::StopCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ThreadHelper
+end
+class Byebug::ThreadCommand::SwitchCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ThreadHelper
+end
+class Byebug::TracevarCommand < Byebug::Command
+  def execute; end
+  def on_change(name, value, stop); end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::UndisplayCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::ParseHelper
+end
+class Byebug::UntracevarCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+end
+class Byebug::UpCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::FrameHelper
+  include Byebug::Helpers::ParseHelper
+end
+module Byebug::Helpers::VarHelper
+  def var_args; end
+  def var_global; end
+  def var_instance(str); end
+  def var_list(ary, binding = nil); end
+  def var_local; end
+  include Byebug::Helpers::EvalHelper
+end
+class Byebug::VarCommand < Byebug::Command
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  extend Byebug::Subcommands::ClassMethods
+  include Byebug::Subcommands
+end
+class Byebug::VarCommand::AllCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::VarHelper
+end
+class Byebug::VarCommand::ArgsCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::VarHelper
+end
+class Byebug::VarCommand::ConstCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  def str_obj; end
+  include Byebug::Helpers::EvalHelper
+end
+class Byebug::VarCommand::InstanceCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::VarHelper
+end
+class Byebug::VarCommand::LocalCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::VarHelper
+end
+class Byebug::VarCommand::GlobalCommand < Byebug::Command
+  def execute; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::VarHelper
+end
+class Byebug::WhereCommand < Byebug::Command
+  def execute; end
+  def print_backtrace; end
+  def self.description; end
+  def self.regexp; end
+  def self.short_description; end
+  include Byebug::Helpers::FrameHelper
+end
+class Byebug::ControlProcessor < Byebug::CommandProcessor
+  def commands; end
+  def prompt; end
+end
+module Byebug::Remote
+end
+class Byebug::Remote::Server
+  def actual_port; end
+  def initialize(wait_connection:, &block); end
+  def start(host, port); end
+  def wait_connection; end
+end
+class Byebug::Remote::Client
+  def connect_at(host, port); end
+  def initialize(interface); end
+  def interface; end
+  def socket; end
+  def start(host = nil, port = nil); end
+  def started?; end
+end
+module Byebug::Printers
+end
+class Byebug::Printers::Base
+  def array_of_args(collection, &_block); end
+  def contents; end
+  def contents_files; end
+  def locate(path); end
+  def parts(path); end
+  def translate(string, args = nil); end
+  def type; end
+end
+class Byebug::Printers::Base::MissedPath < StandardError
+end
+class Byebug::Printers::Base::MissedArgument < StandardError
+end
+class Byebug::Printers::Plain < Byebug::Printers::Base
+  def contents_files; end
+  def print(path, args = nil); end
+  def print_collection(path, collection, &block); end
+  def print_variables(variables, *_unused); end
+end
+class Byebug::AutoprySetting < Byebug::Setting
+  def banner; end
+  def initialize; end
+  def value; end
+  def value=(val); end
+end
+class Byebug::StackOnErrorSetting < Byebug::Setting
+  def banner; end
+end
+class Byebug::HistfileSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::WidthSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::SavefileSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::FullpathSetting < Byebug::Setting
+  def banner; end
+end
+class Byebug::BasenameSetting < Byebug::Setting
+  def banner; end
+end
+class Byebug::ListsizeSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::AutolistSetting < Byebug::Setting
+  def banner; end
+  def initialize; end
+  def value; end
+  def value=(val); end
+end
+class Byebug::AutosaveSetting < Byebug::Setting
+  def banner; end
+end
+class Byebug::CallstyleSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::PostMortemSetting < Byebug::Setting
+  def banner; end
+  def initialize; end
+  def value; end
+  def value=(val); end
+end
+class Byebug::HistsizeSetting < Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+class Byebug::AutoirbSetting < Byebug::Setting
+  def banner; end
+  def initialize; end
+  def value; end
+  def value=(val); end
+end
+class Byebug::LinetraceSetting < Byebug::Setting
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+class Exception
+  def __bb_context; end
+end