rack/rack
Rack
Rack is a minimal interface that standardizes how Ruby web servers and frameworks communicate. It provides a web application interface and a web server interface, enabling Ruby applications to run across different server implementations by using a common environment hash and a standardized response tuple.
The project implements a modular HTTP middleware pipeline, allowing requests and responses to be intercepted and modified through a sequence of callable objects. It supports low-level connection management, including TCP connection hijacking for custom protocol handling, protocol upgrade signaling, and bi-directional data streaming.
The capability surface extends to request and response handling, including binary request stream reading and incremental response streaming. It provides tools for session management, application path routing, and the delivery of static files from the local filesystem. For quality assurance, it includes utilities for mocking HTTP traffic and simulating server environments.
The project includes a command-line tool to launch compatible web servers for hosting applications.
Features
- Web Environment Interfaces - Provides a standardized environment hash to decouple web servers from application logic.
- Web Server Interfaces - Provides a standardized interface that decouples Ruby web servers from the frameworks they host.
- Binary Request Stream Interfaces - Enables access to raw HTTP request bodies via binary-mode input streams with buffered reads.
- Response Tuple Specifications - Standardizes the server response as a simple array containing a status code, response headers, and a body.
- HTTP Request and Response Handlers - Provides comprehensive tools for processing raw request streams and managing HTTP response delivery.
- Request Interception Middleware - Implements a modular middleware pipeline to intercept and modify requests and responses.
- HTTP Middleware Pipelines - Implements a modular pipeline of callable objects to intercept and modify HTTP requests and responses.
- Ruby Web Server Interfaces - Standardizes how Ruby web servers and frameworks communicate via a common environment hash and response tuple.
- Web Application Interfaces - Provides a specification that enables Ruby applications to run across different server implementations without modification.
- Session Data Stores - Provides a standardized hash-like interface for storing and retrieving persistent user data across requests.
- Response Body Streaming - Implements incremental response body delivery using a callable object that responds to each.
- Response Body Callbacks - Handles two-way server-client communication by passing a callback as the response body.
- Connection Hijacking - Allows taking direct control of raw TCP connections to bypass standard request-response cycles.
- TCP Connection Hijacking - Allows direct control of raw TCP connections to bypass standard request-response cycles.
- Application Instance Routing - Maps specific URL paths to different application instances within a single process.
- Application Environment Mocking - Includes utilities to simulate the server environment and response tuples for application testing.
- API Request Mocking - Simulates requests and responses in a testing environment to verify application behavior.
- HTTP Traffic Simulation - Includes utilities to simulate HTTP requests and responses for testing application behavior.
- Incremental Response Streaming - Provides the ability to stream HTTP response bodies incrementally to the client.
- Multipart Form Parsing - Parses multipart/form-data requests to extract uploaded files and form fields.
- Protocol Upgrades - Enables signaling the web server to upgrade the protocol via environment headers.
- Filesystem Static File Servings - Delivers static files and directory indexes from the local filesystem to the client.
- Static File Servers - Includes a built-in implementation for serving static files and directory indexes from the filesystem.
Star history
How this analysis was created: This summary and feature list were written by an AI model that read the project's README and public documentation pages. Each feature links to the documentation it came from; stars, license and language come straight from the GitHub API. The model does not read the source code, and the analysis is refreshed when the project is re-analysed. Learn more on our About page.
