Workflow Tools

binding.irb pauses the program at that line and opens an IRB prompt inside that scope, with its locals, self and instance variables live. exit (or Ctrl-D) resumes the program from that line; exit! ends the process.

A Rakefile is Ruby: task release: %w[build tag] do ... end runs its prerequisites first, each at most once per run. desc describes the next task, rake -T lists only described tasks, and a bare rake runs the task named default.

The debug gem, bundled with Ruby since 3.1, defines binding.break (aliases binding.b and debugger) once require "debug" has started a session; execution stops there at an (rdbg) prompt. rdbg runs a script or, with -c, a command under the debugger without editing code.

YARD reads @tags from the comment above a method: @param name [Type] for each positional or keyword argument, @return [Type] for the result, @raise [ErrorClass] for exceptions and @example for indented usage code. yard doc renders them as structured HTML.

IRB's ls lists an object's methods, constants and variables (-g filters them); show_source prints a Ruby method's definition; show_doc looks up its RDoc; cd moves self into an object; edit opens the file in your editor; help lists them all.

In the debug gem, step enters the next call, next runs to the next line of the same method, finish runs until the current method returns, and continue runs to the next breakpoint. info lists locals; bt prints the call stack.

ri prints installed Ruby documentation in the terminal: Array#sort names an instance method, IO::readlines a class method, and IO.readlines matches both. A gem installed with --no-document has no ri data, so ri reports Nothing known about it.

In IRB, _ holds the value of the last evaluated expression, or the exception object if that input raised. __ is the numbered history of results, and exists only after setting IRB.conf[:EVAL_HISTORY] or conf.eval_history.

In the debug gem, break sets a breakpoint on a line or a method (break tax_calc.rb:15, break TaxCalculator#tax_on) and accepts if: for a condition; catch KeyError stops when that exception is raised, even if it is rescued later.

binding.pry opens Pry, a richer console with no stepping; pry-byebug adds byebug's stepping to it; byebug is a standalone C-extension debugger. For a new Ruby 4.0 project the default is the debug gem, bundled with Ruby, with stepping, remote attach and editor integration.

RDoc documents public and protected methods by default; a trailing # :nodoc: hides a definition and # :doc: forces one in, such as a private method. YARD ignores those directives and uses @api private or @private with --hide-api private or --no-private.

IRB's debug command hands the paused binding.irb session to the debug gem: the prompt becomes irb:rdbg and commands like next and step work beside IRB's own. It refuses outside binding.irb, in multi-irb mode, or without a loadable debug gem.

A Rake file task runs only if its file is missing or older than a prerequisite's timestamp. A plain task's timestamp is always the current time, so a file task depending on one always rebuilds; rake/phony's phony task avoids that.

Rake::Task#invoke runs prerequisites and then the actions, but only on the first call in a run; later calls return immediately. #execute runs only the actions, every time, skipping prerequisites. #reenable resets the flag so invoke runs again.

Declare argument names after the task name, task :bump, [:version] do |t, args|, and pass values as rake bump[1.4.0]; they arrive as Strings, missing ones as nil. rake bump VERSION=1.4.0 instead sets ENV["VERSION"] for the whole run.

RBS declares Ruby types in separate .rbs files, usually under sig/: def name: (Integer, ?String, key: Symbol) -> String. A leading ? marks an optional parameter, a trailing ? a nilable type, and { (T) -> void } a block.

steep init writes a Steepfile; a target lists the Ruby to check and the sig directory. rbs collection install supplies gem signatures, and steep check reports mismatches such as Ruby::NoMethod on a value that may be nil.

Start the program as a debuggee with rdbg --open (or require "debug/open"), then connect a console with rdbg -A. It listens on a UNIX socket by default or TCP with --port; the channel is unencrypted and grants code execution, so keep it local.

IRB loads every rc file it finds: the IRBRC path, the XDG config file, ~/.irbrc or ~/.config/irb/irbrc, then .irbrc in the current directory. Each is plain Ruby, so a repository's .irbrc runs arbitrary code; irb -f skips them.

Rake's multitask runs a task's immediate prerequisites in parallel on a thread pool sized by -j. It helps when they shell out or wait on I/O; shared prerequisites still run once, but Ruby data they share needs synchronisation.

A Sorbet sig is Ruby code, sig { params(cents: Integer).returns(Receipt) }, checked statically by srb tc and, with sorbet-runtime, on real calls. RBS lives in .rbs files or experimental # @rbs comments, has no runtime cost and is checked by Steep.

Since Ruby 3.4 IRB defaults to IRB::TypeCompletor, which uses the repl_type_completor gem and RBS to infer receiver types, so chained calls and block parameters complete. If that gem cannot load, as under a Gemfile that omits it, IRB quietly uses IRB::RegexpCompletor.

rbs prototype rb reads only the syntax, so it emits every class, method and instance variable with mostly untyped types. TypeProf abstractly runs the code and infers real types from the calls it sees; both outputs are drafts to edit.

yard stats --list-undoc prints a % documented figure and lists each undocumented public object with its file and line; it does not fail on gaps by itself. yard doc --fail-on-warning exits non-zero on warnings such as an unknown @param name.

Subclass Rake::TaskLib, which includes Rake::DSL, collect options in initialize (yield self), then define the tasks inside namespace :gem so they become gem:build and gem:release. Each Rakefile adds the whole set with one ReleaseTasks.new call.

Start with the public API and money-handling paths, seed signatures with rbs prototype and TypeProf, check them with lenient Steepfile targets that tighten over time, validate signatures against the test suite with RBS_TEST_TARGET, and track progress with steep stats.