pry/pry
Pry
Pry is a programmable Ruby shell, REPL console, and runtime developer environment. It serves as a debugging toolkit for inspecting object state, navigating bindings, and evaluating code within a running Ruby program.
The project differentiates itself through advanced introspection and live iteration capabilities. It allows users to inject an interactive console into a running program at specific points to inspect local state and navigate different object scopes. It further enables live code iteration by integrating with external system editors to modify and reload method definitions without restarting the session.
The tool covers a broad surface of developer utilities, including callstack stepping and exception state analysis for debugging. It provides source code browsing and documentation retrieval with syntax highlighting, alongside a pluggable command registry for extending the shell's functionality. Additional capabilities include shell command execution, session history management, and performance benchmarking for evaluated expressions.
Features
- Debugging Consoles - Implements an interactive console that can be injected into a running program to inspect local state and execute arbitrary code.
- Interactive REPLs - Implements a programmable read-eval-print loop for executing code snippets and inspecting state in real time.
- Programmable Shells - Serves as a programmable Ruby shell supporting command macros and plugins for advanced developer workflows.
- Runtime Variable Inspection - Provides tools for exploring local and instance variable values and scopes during runtime execution.
- Object Hierarchy Navigation - Moves the session context into different objects or namespaces using directory-like syntax to explore internal state.
- Code Exploration Tools - Provides a programmable shell for navigating object scopes, browsing source code, and testing snippets without restarting.
- Command Line Extensions - Implements a pluggable command registry allowing users to define custom commands and extensions for the interactive shell.
- Interactive Console Injection - Opens an interactive session at a specific point in a running program to inspect current state and bindings.
- Real-Time Code Evaluation - Executes code fragments immediately to provide instant feedback without restarting the process.
- Debugging and Inspection Tools - Provides an interactive suite for stepping through code and inspecting exception backtraces in real-time.
- Runtime Debugging - Provides a toolkit for inspecting and troubleshooting application logic within active processes through an interactive console.
- Interactive Debug Consoles - Provides an interactive debug console for real-time execution of code snippets and logic testing during active sessions.
- Live Source Editing - Allows modifying source files in an external editor and automatically reloading changes into the running session.
- Read-Eval-Print Loops - Implements a programmable read-eval-print loop for executing and testing Ruby code snippets in real-time.
- Runtime Source Browsers - Displays the implementation of methods with syntax highlighting and line numbers for both high-level and native code.
- Source Code Viewers - Displays the source code for classes, methods, or objects, including those modified by monkeypatches or native extensions.
- Callstack Navigation - Provides capabilities to execute code line-by-line and navigate the callstack by moving up, down, or jumping between frames.
- Binding Navigation - Allows users to move the session context into different objects or namespaces using directory-like syntax to explore internal state.
- Contextual Binding Navigation - Allows users to move the session context into and out of different objects or bindings to explore internal state.
- Runtime Introspection - Uses language metadata to retrieve source code, method definitions, and documentation for objects at runtime.
- Program State Inspection - Implements capabilities for traversing variables and performing dynamic introspection on internal runtime state.
- Object Member Listing - Displays a formatted list of local variables, instance variables, and available methods in the current context.
- Exception Backtrace Inspection - Navigates the backtrace of the last raised exception and displays the surrounding source code for error analysis.
- Exception Context Analysis - Navigates the callstack of raised exceptions to inspect surrounding source code and variable state.
- Code Documentation Retrieval - Extracts comments from source code or queries documentation indices to retrieve information for specific methods or classes.
- Startup Timers - Includes utilities to measure and track the total duration of the environment initialization process.
- Command Registries - Ships a pluggable registry that allows the shell to be extended with new custom commands or external command sets.
- Framework Inspection Tools - Provides specialized commands to examine framework-specific state, such as application routes and data models, from the console.
- Inline Expression Debugging - Monitors specific expressions or variables over time to observe how their values change during execution.
- Documentation Viewers - Retrieves and displays formatted documentation for classes and methods using syntax highlighting for readability.
- External Editor Integrations - Provides integration that allows launching and positioning source files in a separate external code editor for modification.
- Hot Code Reloading - Enables updating class and method definitions in the active session by re-evaluating source files without restarting the process.
- Pattern-Based Method Search - Searches across a namespace for methods that match a specific regular expression or contain specific code patterns.
- Shell Command Execution - Allows the execution of operating system shell commands and interpolation of runtime expressions directly from the prompt.
- Third-Party Plugins - Supports loading third-party plugins via command-line flags to extend the core functionality of the shell.
- Programmatic Plugin Loading - Provides controls to programmatically toggle the loading of plugins and initialization of configuration files during runtime.
- Operation Benchmarkers - Measures and displays the execution time of specific evaluated expressions to identify performance bottlenecks.
- IRB Enhancements - Powerful alternative shell for interactive Ruby development.
