ruby/rubygems

Features

• Dependency Installers - Automates the retrieval and installation of libraries and their recursive dependencies from remote registries.
• Ruby Dependency Managers - Provides the primary system for resolving and installing Ruby gem dependencies to ensure consistent environments.
• Package Installations - RubyGems downloads and installs a library from local or remote sources into a repository.
• Recursive Dependency Resolution - Computes a compatible set of library versions by traversing a recursive tree of requirements and constraints.
• Organization-Based Access Management - Provides role-based access control for team members to manage libraries and organizational settings.
• Registry Organizations - Establishes shared organizational entities to manage multiple packages under a single identity and handle.
• C Extension Compilation - Executes platform-specific build scripts to compile C-based extensions for high-performance system access.
• Custom Load-Path Extensions - Automatically extends the system load path to incorporate library directories when code is required.
• Package Publishing - Uploads and distributes project packages to registries for version management and code sharing.
• Ownership Management - Assigns package ownership to collective organization identities to ensure continuity during team transitions.
• Package Search - Implements search and discovery mechanisms for finding available libraries within the registry.
• Dependency Analysis - Identifies and tracks the relationship between installed packages and their required dependencies.
• Source Specifications - Specifies multiple fetch locations for libraries, including public servers, private registries, and Git repositories.
• Development Dependency Management - RubyGems specifies separate sets of libraries required for production execution versus local development and testing.
• Standard Library Management - RubyGems handles the installation and updating of core libraries shipped with the environment.
• Package Sources - Defines custom dependency indexes, remote repository URIs, and authentication credentials for private assets.
• Package Uninstallers - RubyGems removes a library from the local system with optional checks for dependent packages.
• Project Dependency Specifications - Defines required libraries and version constraints in a manifest file to ensure consistent environment setups.
• Version Locking - Generates lockfiles that record specific dependency versions and checksums to guarantee reproducible environments.
• Package Metadata Indexing - Creates specification files and index metadata required for a static package source to be discoverable.
• Team-Scoped Access Control - Controls authority over packages and organization settings through team-scoped roles and permissions.
• Isolated Package Deployment - Installs all required libraries into a project-specific directory to isolate the application from global packages.
• Library Distribution Bundlers - Packages applications or libraries into optimized artifacts for distribution via registries.
• Dependency Version Locking - Creates a snapshot of exact versions of all installed libraries to guarantee reproducible environments.
• Package Metadata - RubyGems specifies a package's name, version, authors, and licenses for distribution.
• Dependency Versioning - Locks specific versions of dependencies in a manifest file to ensure identical environments across commits.
• Dependency Version Updates - RubyGems updates a specific package to a newer version while preserving other dependencies to prevent regressions.
• Version Constraints - RubyGems limits compatible library versions using optimistic or pessimistic requirements to prevent breaking changes.
• Dependency Load Path Management - Configures the runtime environment to resolve and load all libraries listed in a dependency file.
• Runtime Search Path Manipulation - Dynamically modifies the runtime load path to resolve and load installed library source files.
• Native Extension Builders - Utilizes build scripts to compile and install native extensions with environment-specific run paths.
• Package Building - Creates a distributable file from a package specification.
• Ruby Package Distribution - Packages Ruby libraries and applications into distributable formats to share reusable functionality.
• Ruby Registry Clients - Provides a client for searching, authenticating, and publishing Ruby packages to remote and private repositories.
• Dependency Version Locking - Implements version locking via manifest files to guarantee reproducible environments across deployments.
• Source Library Packaging - Bundles source files and linked libraries into a distributable format containing a dependency manifest.
• Package Ownership Management - Manages membership and access control roles for coordinating the maintenance of shared software packages.
• Package Integrity Verifications - Validates cryptographic signatures and checksums during installation to ensure packages have not been tampered with.
• Package Signing - Attaches RSA signatures and checksums to packages to ensure code integrity and origin authenticity.
• Role-Based Access Control - Implements a role-based system to regulate administrative actions and library management.
• Organization Role Assignments - Assigns access roles to users at the organization level to control shared package management.
• Shared Package Permissions - Allows granting multiple maintainers the authority to push updates to shared packages on the remote registry.
• Ruby C Extension Packaging - Bundles C code as reusable Ruby gems to provide high-performance native extensions.
• Library Ownership Transfers - Provides mechanisms for reassigning administrative control of libraries from individual accounts to organizations.
• Package Index Compression - Uses a compact text index for metadata retrieval to minimize data transfer and improve caching.
• Remote Registry Indexing - Fetches compact metadata files from a central server to discover available package versions efficiently.
• Versioned Binary Execution - Executes command-line tools provided by dependencies within a versioned environment to avoid system-wide conflicts.
• Cross-Platform Build Targets - Restricts packages to particular operating systems to enable pre-compiled binary builds.
• Dependency Consistency Validators - Checks if the locked version of dependencies matches the defined requirements to ensure production stability.
• Dependency Groups - Organizes libraries into named sets to conditionally install or load them based on the environment.
• Event Hooks - Provides mechanisms for triggering custom logic in response to internal lifecycle events.
• Executable Script Installation - RubyGems lists scripts to be installed as command-line binaries when the package is deployed.
• Git-Based Dependency Installations - Installs software libraries directly from remote Git repositories using specific branches, tags, or commits.
• Local Dependency Overrides - RubyGems redirects a remote git dependency to a local repository to allow immediate testing of changes.
• Registry Package Removals - Deletes specific package versions from a remote registry index to prevent further installations.
• Loading Control - Provides mechanisms to select which specific groups of dependencies are added to the load path during startup.
• Package Mirror Hosting - Runs a local copy of a remote registry to improve reliability and speed of internal installations.
• OIDC Package Publishers - Automates releases by using short-lived identity tokens from CI providers instead of static API keys.
• Package Script Execution - Provides utilities for executing custom commands defined within package manifests.
• Private Package Registries - Supports hosting and distributing internal software packages within an organization through private registries.
• Pre-release Versioning - Manages non-stable version identifiers such as alpha, beta, and release candidates.
• Environment-Aware Command Executions - Runs executable scripts within an isolated project environment of locked dependencies.
• Package Executable Pathing - Automatically adds executable files bundled in a package to the system path upon installation.
• Custom Source Configurations - Allows directing the manager to fetch libraries from internal servers instead of the public repository.
• Custom Installation Sources - Supports retrieving packages from non-standard locations like cloud storage or version control systems.
• Package Downloading - RubyGems downloads package files from a remote source for local storage or unpacking.
• Outdated Package Listings - Provides commands to display which installed packages have newer versions available for upgrade.
• Private Package Hosting - Provides a dedicated environment to store and distribute internal libraries privately.
• Private Repository Hosting - Uses cloud storage buckets to store and serve private packages without managing a dedicated server.
• Repository Mirrors - Synchronizes remote software repositories to local servers to ensure high availability and speed.
• Version Upgrades - Identifies libraries with available newer versions and upgrades them while respecting version constraints.
• Locked Version Updates - Refreshes specific libraries to the latest compatible versions while respecting defined version constraints.
• Installed Package Inspection - Lists all files contained within an installed library, including filterable views for required files.
• Installed Package Listing - Displays all locally installed libraries, including those shipped by default with the runtime.
• Environment Isolation - Provides mechanisms for installing libraries into project-specific directories to avoid conflicts between applications.
• API Key Lifecycle Management - Provides a command-line interface to create and update scoped API keys for CI automation.
• API Key Management - Provides a system for generating and managing API keys to secure programmatic access to the registry.
• Client-to-Server Authentication - Handles secure client-to-server authentication for managing credentials and uploading packages to registries.
• API Key Scopes - Implements granular scopes for API keys to restrict actions and enforce the principle of least privilege.
• CI/CD OIDC Token Exchanges - Supports swapping OIDC identity tokens from CI providers for short-lived API keys to enable secure automated publishing.
• Multi-Factor Authentication - Requires a second verification step via tokens or hardware keys for logins to enhance account security.
• Package Signing Key Management - Generates and manages RSA keys and certificates specifically for signing packages for security verification.
• Passkey Authentication - Supports passwordless authentication using hardware security devices or passkeys for secure login.
• Repository Trust Verifiers - Enforces security policies that restrict the installation of dependencies based on their signature and verification status.
• Mandatory MFA Enforcement - Mandates multi-factor authentication for all package owners as a prerequisite for publishing new versions.
• Sensitive Action MFA - Forces one-time password verification for sensitive commands executed via API keys.
• Toolchain Version Enforcement - Enforces required language versions and engines to prevent applications from running on incompatible systems.
• Core Logic Extensions - Implements architectural hooks that allow the injection of custom logic into the package lifecycle.
• Plugin Integrations - Integrates third-party plugins to add custom hooks and specialized installation behaviors to the workflow.
• Package Naming Guidelines - RubyGems follows a naming convention to signal the correct file structure for requiring the library in code.
• Package Detail Retrievers - Provides APIs to fetch detailed metadata and specifications for specific package versions.
• Hook-Based Plugin Systems - Allows third-party plugins to register custom logic into the installation and build lifecycle.

Star history