This repository is a pure PHP implementation of the AMQP 0-9-1 protocol for interacting with RabbitMQ message brokers. It provides a robust client library handling connection management, channel multiplexing, message publishing/consuming, and wire-level protocol frame encoding/decoding. The architecture features layered abstractions: connection layer (TCP/socket handling), channel layer (logical channels over connections), message layer (AMQP message structure), and wire layer (binary serialization/deserialization). Key entry points include AMQPStreamConnection (primary connection interface) and AMQPChannel (queue/exchange operations). Data flows involve: publishing (user → channel.basic_publish() → AMQPWriter → socket → broker) and consuming (broker → socket → AMQPReader → channel.basic_consume() → user callback). The library supports advanced features like publisher confirms, consumer cancellation notifications, heartbeat monitoring, and batch publishing. The codebase demonstrates strong engineering practices: clear separation of concerns, extensive unit/functional test suite, protocol version handling via generated code from JSON specifications, and active maintenance with recent commits. While supporting broad PHP versions (5.6-8.5), it has dropped older versions showing proactive maintenance. Dependencies are minimal (sockets extension required, pcntl optional for signals). The library is production-ready for building distributed systems requiring reliable asynchronous messaging.
ProjectSend is a self-hosted secure file sharing platform built as a modular Laravel application with an Inertia.js + React frontend. The codebase is organized into domain modules — Files, Clients, Groups, Identity, Comments, Notifications, Audit, Platform, and Api — each containing controllers, services, policies, models, and event hooks. Staff members upload and share files with clients or groups, manage roles and permissions, enforce download limits, expire or version files, and monitor activity through a detailed audit log. Clients access their own portal with four switchable themes (default, compact, drive, gallery), and public share links support additional presentation themes with pagination, previews, and controlled downloads. The application is a monolith with strong modular boundaries rather than microservices. Authentication supports local accounts, LDAP, social login/SSO via OIDC, two-factor authentication, CAPTCHA, and password policies. A REST API protected by Sanctum tokens offers scoped abilities, RFC 7807 problem details, polling-based pagination, and an OpenAPI contract that is drift-tested against the live route surface. Background jobs handle zip downloads, email digests, thumbnails, file cleanup, and scheduled maintenance. The system persists settings, activity logs, notification preferences, and upload metadata in a relational database, while file payloads can be stored on local disks, S3-compatible storage, or Google Cloud Storage. The code is notably security-conscious: secrets are encrypted at rest, old input flashing excludes credentials, CSRF cookie naming is customized to avoid collisions, download paths are never exposed in API responses, and regression tests cover disclosure boundaries, permission scoping, token revocation, and account erasure. The test suite is extensive, using Pest feature tests to exercise permissions, file lifecycle edge cases, version chains, comment visibility, API contracts, and authentication flows. The architecture favors event-based extension points and registry patterns, making modules independently testable and partially reusable, though the project remains an application rather than a framework or library. Overall this is a well-crafted, actively maintained application with clean engineering practices, clear separation of concerns, and unusually thorough security regression coverage. Its main complexity is the large surface area of interchangeable themes, editions, authentication backends, and storage drivers, which creates some ongoing drift risk, but current CI, recent commits, and dependency management show the project is keeping pace with its ecosystem.
This is a production Laravel application that powers the real-time office dashboard at Spatie (dashboard.spatie.be). It displays a rotating set of screens on a wall-mounted TV, showing team member statuses, GitHub/Packagist statistics, climate data, cookie club ratings, now-playing music, Officient calendar attendance, Oh Dear uptime alerts, and product analytics from Fathom. The architecture is a monolith built on Laravel 12 with Livewire 4 for reactive components, Tailwind CSS 4 for styling, and Pusher/WebSockets for real-time updates. Key entry points are the main dashboard route (/) and webhook endpoints for now-playing songs and Oh Dear alerts. Data flows from external APIs (Fathom, GitHub, Packagist, Slack, Officient, Apple Music, Last.fm, climate sensors, Cookie Club) into database-backed tile stores, which are polled by Livewire components. The system includes a screen scheduler with conditional visibility, a weekplanning overlay, and a deploy-status endpoint for automatic page reloads. The codebase is well-structured, follows Laravel conventions, and includes comprehensive tests. While the dashboard is tailored to Spatie's internal use, many components (Fathom analytics service, forecast calculator, path normalizer, screen availability checker, weekplanning logic) are cleanly abstracted and could be reused in other dashboard or analytics projects.
This is a Laravel package that monitors scheduled tasks by logging their start, finish, failure, and skip events to a database table. It provides three Artisan commands: `schedule-monitor:sync` to register tasks from the scheduler into a `monitored_scheduled_tasks` table, `schedule-monitor:list` to display their status with visual indicators for late or failed runs, and `schedule-monitor:verify` to check connectivity with the Oh Dear monitoring service. The package integrates deeply with Laravel's scheduling system through event subscribers (`ScheduledTaskEventSubscriber`, `BackgroundCommandListener`) that listen to core scheduler events and update the database accordingly. It also optionally syncs tasks with Oh Dear, pinging external endpoints on task start, finish, or failure, using a queued job (`PingOhDearJob`) with configurable retry logic and custom job support. The architecture is clean and follows Laravel package conventions: a service provider registers macros on scheduler events, configurable model bindings allow custom model classes, and a singleton (`MonitoredScheduledTasks`) stores per-task monitoring configurations (like custom names, grace times, and opt-out flags) using an in-memory array keyed by object hash. While the package is tightly coupled to Laravel's console scheduler and cannot be extracted as a standalone library, its internal patterns—such as the polymorphic `Task` hierarchy (CommandTask, JobTask, ClosureTask, ShellTask) and the `Payload` strategy for building Oh Dear ping data—demonstrate strong software design.
Laravel Visits is a Laravel package that provides visit tracking functionality for Eloquent models. It implements a counter system with IP-based deduplication, period-based tracking (day, week, month, year), and visitor metadata collection (country, referrer, OS, language). The architecture features a pluggable data engine abstraction supporting both Redis and Eloquent/database storage, with traits separating concerns like listing, period handling, recording, and setting configuration. The package integrates with Laravel via a service provider and offers a simple helper function for accessing visit tracking capabilities on any model.
Bagisto is a production-ready open-source eCommerce platform built on Laravel with a modular monolith architecture. It provides a complete admin panel and storefront for managing multi-channel, multi-locale, multi-currency online stores. The system supports a wide range of product types (simple, configurable, bundle, grouped, downloadable, virtual, booking), payment gateways (Stripe, PayPal, Razorpay, PayU, PhonePe, PayGlocal), marketing promotions (cart rules, catalog rules), full-page caching, Elasticsearch integration, GDPR compliance, EU withdrawal management, RMA (returns), data import/export, and AI-powered features (MagicAI). The architecture is event-driven with listeners for cache invalidation, notifications, and indexing. The admin panel uses Vue 3 components with Blade templates, while the storefront is built with Tailwind CSS and Vue. The codebase is organized into ~40+ packages under packages/Webkul/, each with its own models, repositories, migrations, translations, and tests. Key entry points include the admin routes (packages/Webkul/Admin/src/Routes/web.php), shop routes (packages/Webkul/Shop/src/Routes/), and the installer wizard. The system relies on MySQL, Redis, Elasticsearch, and various external payment/shipping APIs. The core framework (Concord) provides facades for core services, ACL, menu, system config, and Elasticsearch. The DataGrid system offers a reusable abstraction for listing and filtering entities across the admin panel. Notable engineering highlights include the CurrencyFormatter trait for locale-aware currency display, the MediaFileName helper for safe file upload handling, the ForgetsPages trait for full-page cache invalidation, and the DynamicMailTransport for configurable email delivery. The event-driven architecture with listeners and the repository pattern are consistently applied across all modules.
DoctrineBundle is a Symfony bundle that integrates Doctrine DBAL and ORM into Symfony applications. It provides dependency injection configuration (YAML/XML/PHP), autowiring of connections and entity managers, console commands for schema management, a web profiler data collector, and middleware support. The bundle uses compiler passes and PHP 8 attributes to automatically register custom types, entity listeners, middlewares, and repository services. It is a mature, well-tested integration layer that bridges Symfony's container with Doctrine's persistence layer, enabling standard CRUD and advanced ORM workflows. The architecture follows Symfony bundle conventions with clean separation of concerns (DependencyInjection, Mapping, Middleware, Repository, Command).
This repository is the endroid/qr-code PHP library for generating QR codes in multiple output formats including PNG, GIF, WebP, SVG, EPS, PDF, binary text, and console output. It provides a clean object-oriented architecture with immutable value objects (QrCode, Color, Matrix), a Builder facade for convenient construction, and a set of Writer classes each implementing WriterInterface. The library delegates low-level QR encoding to BaconQrCode and handles matrix rendering, logo overlays, and label placement. It includes optional validation by decoding the generated image. The code is modern PHP 8.4, utilizing readonly classes, enums, named arguments, and strict typing. The separation of concerns is clear: QrCode holds data parameters, Matrix encapsulates the binary grid and size calculations, Writers produce format-specific results, and Results provide uniform access to the output. The Builder aggregates all common options and allows per-call overrides. The library is well-maintained with active CI, zero dependabot alerts, and runs on the latest PHP versions.
Collision is a PHP library that provides beautiful error reporting for CLI applications, particularly integrated with Laravel, PHPUnit, and Pest. It wraps the Whoops error handler to render exceptions with syntax-highlighted code snippets, stack traces, and solution suggestions. Additionally, it includes a custom PHPUnit/Pest test printer that outputs test results with color-coded summaries, warnings, and slow-test profiling. The library is built on top of Symfony Console, Termwind, and Whoops, and is designed as a drop-in replacement for default error handling in Laravel's artisan commands and PHPUnit test runners. The codebase is well-structured with clear separation of concerns: core error rendering (Provider, Handler, Writer), terminal styling (ConsoleColor, Highlighter), argument formatting (ArgumentFormatter), code coverage reporting (Coverage), and framework-specific adapters (Laravel service provider, PHPUnit event subscribers). The PHPUnit adapter demonstrates advanced event-driven architecture by hooking into PHPUnit's event system to produce a rich, compact test output.
This is a PHP library that converts HTML strings to Markdown. It parses HTML into a DOMDocument, then recursively traverses the DOM tree, converting each node to its Markdown equivalent using a registry of converter classes. The architecture is clean: an `HtmlConverter` orchestrates the process, an `Environment` manages configuration and converter registration, and individual converter classes handle specific HTML elements (headers, links, lists, tables, etc.). The library supports extensive configuration options including stripping tags, preserving comments, customizing emphasis styles, and enabling table conversion. It provides both a programmatic API and a CLI binary. The code is well-structured with strict typing, interfaces, and comprehensive test coverage. It demonstrates solid software engineering practices and is actively maintained.
Nette Mail is a standalone PHP library for creating and sending emails with support for SMTP, sendmail, DKIM signing, and fallback mechanisms. It provides a clean API for composing emails with HTML/text bodies, attachments, embedded images, and automatic text alternative generation. The architecture follows a modular design with separate concerns for message creation (Message/MimePart), sending (multiple Mailer implementations), signing (DkimSigner), and HTML processing (HtmlComposer, CssInliner). The library is framework-agnostic but integrates well with Nette DI and Tracy debugging tools.
This repository implements a self-hosted deployment platform alternative to services like Vercel or Netlify. It enables users to deploy GitHub repositories with zero-downtime updates, instant rollback, and preview deployments for branches. The platform provides team-based access control, custom domain support with automatic Let's Encrypt SSL, storage provisioning (databases/volumes), and real-time log aggregation via Loki. Built with FastAPI, SQLAlchemy, and ARQ for background jobs, the architecture separates concerns into routers, services, models, utilities, and workers. Infrastructure is orchestrated via Docker Compose, including Traefik for routing, PostgreSQL for primary data, Redis for caching/job queue, and Loki/Alloy for logs. Key entry points include the main FastAPI app, API routers for auth/project/team/admin, and worker entrypoints for ARQ jobs and deployment monitoring.
Phinx is a PHP library and CLI tool for managing database migrations and seeding. It supports MySQL, PostgreSQL, SQLite, and SQL Server, providing a fluent API to define schema changes (tables, columns, indexes, foreign keys) and execute them across multiple environments. The architecture is built around database adapters implementing a common interface, a migration manager for orchestration, and a flexible configuration system (YAML/JSON/PHP). Key design patterns include Action objects for atomic database changes, a Plan/Intent system for conflict resolution, and decorator wrappers for cross-cutting concerns like table prefix/suffix and performance timing. The tool integrates with Symfony Console for CLI commands and can be embedded in web applications via a TextWrapper. The codebase demonstrates strong software engineering with extensive test suites, feature flags for backward compatibility, and support for reversible migrations via the `change()` method. While some adapter code is duplicated and Docker test images are outdated, the overall structure is clean and modular, making it a reliable choice for PHP database schema management.
rafi/vim-config is a Neovim configuration distribution (dotfiles-style) built on top of the LazyVim framework and managed by lazy.nvim. It transforms vanilla Neovim into a full IDE: lazy-loaded plugins provide LSP via nvim-lspconfig + mason.nvim, completion via blink.cmp (or nvim-cmp as an extra), telescope/snacks pickers, git workflows (gitsigns, diffview, neogit, blame), treesitter syntax, and a heavily customized lualine statusline. The runtime entry point is init.lua → lua/rafi/config/lazy.lua, which bootstraps lazy.nvim, imports the LazyVim framework plus ~15 core plugin-spec modules under lua/rafi/plugins/, and layers custom options, keymaps, and autocommands on top of LazyVim defaults via targeted User autocmds. An 'extras' system (registered in lua/rafi/config/init.lua) exposes ~50 opt-in plugin specs — colorschemes, language packs, org-mode tools, UI widgets — toggleable via :LazyExtras, making the distribution both opinionated and modular for fork-and-extend use. The codebase is idiomatic Lua organized into config/, plugins/, and util/ namespaces. It makes sophisticated use of lazy.nvim's spec merging (optional = true, opts = function(_, opts) patterns), a metatable-driven util facade (lua/rafi/util/init.lua) that lazily loads submodules, and recent Neovim APIs (vim.diagnostic.jump, nvim 0.11 features, tree-sitter-manager instead of the deprecated nvim-treesitter ensure_installed). Highlights for reuse include a small completion/snippet helper that abstracts LuaSnip vs native vim.snippet, color-theory utilities, a floating preview helper, and filetype plugins with proper undo_ftplugin hygiene. Documentation is extensive but partially stale: the README references paths that no longer exist in the tree (e.g. lua/rafi/plugins/lsp/keymaps.lua, lua/rafi/util/contextmenu.lua), so the code is the reliable source of truth. Dependencies: Neovim ≥ 0.11.2, git, lazy.nvim, LazyVim, and roughly 80 third-party Neovim plugins pinned via lazy-lock.json. Optional external CLIs (rg, fd, fzf, bat, zoxide, lazygit) improve picker and git behavior but degrade gracefully. This is not a data repo; it contains no pipelines, notebooks, or datasets. It is an application-distribution-style repo: a carefully engineered editor config demonstrating mature Neovim plugin-spec and Lua patterns.
This repository is a Laravel package (library) that extends the native Illuminate\Support\Collection with over 50 additional macros, such as `chunkBy`, `transpose`, `validate`, `weightedRandom`, and a `try`/`catch` proxy. It is built and maintained by Spatie and is one of the most popular collection macro libraries in the Laravel ecosystem. The architecture is straightforward: a service provider (`CollectionMacroServiceProvider`) registers each macro as a closure on the Collection class at boot time. Each macro is defined as a separate invokable class in the `src/Macros/` directory, making the codebase modular and easy to test. There is no persistent state, database, or external service integration; the package operates purely in-memory on Collection objects. The primary entry point is the service provider auto-discovered by Laravel's package discovery. External dependencies are minimal (`illuminate/support` for the base Collection class, and optionally `amphp/parallel-functions` for the `parallelMap` macro). The code exhibits high craftsmanship: macros are concise, well-documented with docblocks, and each has dedicated Pest tests. Notable patterns include the `CatchableCollectionProxy` helper, which implements a fluent try/catch mechanism on collections using reflection for exception type matching, and the `WeightedRandom` macro with a clean weighted selection algorithm. The codebase is actively maintained, supporting Laravel 12 and 13 with PHP 8.2-8.5, and shows no signs of technical drift. It is not an application or service; it is a reusable library that can be dropped into any Laravel project to enrich collection operations.
This repository provides a native PHP implementation of enumeration types, offering base Enum class, EnumSet for efficient set operations, and EnumMap for mapping enum keys to values. The Enum class implements the singleton pattern for enum values, ensuring that equivalent enum values are identical instances, and includes features like lazy constant discovery, inheritance support, and proper comparison handling. The EnumSet component stands out for its innovative bit vector implementation that automatically switches between integer storage (for small sets) and binary string storage (for large sets) to optimize memory usage and performance. It provides standard set operations (union, intersection, difference, symmetric difference) through efficient bitwise operations, making it particularly valuable for applications requiring efficient set manipulation on enum values. The library is well-maintained with comprehensive test suites, benchmarks, and support for multiple PHP versions. It follows semantic versioning and includes development tools for code quality checking. While the EnumSerializableTrait provides serialization support with noted caveats, the core enum functionality is robust and suitable for use in production PHP applications requiring type-safe enumeration patterns.
TelegramRSS is a PHP web service that acts as a proxy between clients and a Telegram API server, providing RSS and JSON feeds of Telegram channel content. Built with AMPHP for asynchronous handling, it features rate limiting, IP-based access control, and middleware-based request processing. The service fetches messages from Telegram via a backend API server and formats them as RSS or JSON responses with media support.
This repository is a CLI tool (`api-platform`) that scaffolds new API Platform projects. It generates Symfony or Laravel project skeletons with optional Docker infrastructure, Next.js PWA, React-admin SPA, and AI agent instruction files. The tool configures API formats (JSON-LD, JSON:API, HAL) and documentation viewers (Swagger UI, ReDoc, Scalar). It fetches Docker files from a pinned commit of `dunglas/symfony-docker` and patches compose.yaml for CORS headers. The codebase is well-structured with clean abstractions, idempotent patching patterns, and comprehensive test coverage. It demonstrates professional PHP engineering using Symfony Console components and modern PHP features.
PrivateBin is a self-hosted, zero-knowledge pastebin web application. The PHP backend (Controller, Model, Data) handles paste/comment lifecycle, expiration, deletion, traffic limiting, and storage backend selection; the JavaScript frontend performs all encryption/decryption in the browser using AES-256-GCM (WebCrypto) with PBKDF2 key derivation and optional zlib/WASM compression. The server only ever stores ciphertext and metadata, never plaintext. Data flows from browser encryption into a pluggable persistence layer (filesystem, PDO database, Google Cloud Storage, S3), then back to the browser for decryption; JSON API endpoints accept and return encrypted bodies. Architecturally it is a classic server-rendered MVC app with a frontend state layer: index.php bootstraps a Controller, which delegates to Paste/Comment models over an AbstractData storage interface. Views are rendered via PHP templates with Bootstrap 3/5 themes, and the frontend is a vanilla-JS module namespace (PrivateBin) with submodules for encryption, editor, viewer, discussion, attachments, and i18n. The feature set includes expiration times, burn-after-reading, password-protected pastes, discussion threads, file attachments, URL shortening proxies (YOURLS/Shlink), QR codes, dark mode, and multi-language support. Engineering practices are strong for a mature open-source project: PHPUnit tests cover backend behavior, fast-check property tests cover frontend utilities, CI includes CodeQL/Snyk scans, and security hardening (DOMPurify, CSP, SRI hashes, HTTPS guidance) is explicit. Maintenance is active with recent commits and issue triage. Technical drift is moderate: the project retains legacy browser support and old Bootstrap 3/darkstrap assets, still supports PHP 7.4, and ships a monolithic JS file without a build step, but pinned frontend libraries (Bootstrap 5.3.8, Showdown 2.1.0, DOMPurify 3.4.17) are current.
The spatie/temporary-directory repository is a PHP library that provides a fluent interface for creating, managing, and cleaning up temporary directories. It allows developers to create temporary directories with optional custom names, locations, and permissions, and provides methods to resolve paths within the directory, empty its contents, and delete it entirely. The library also supports automatic cleanup when the TemporaryDirectory object is destroyed, reducing the risk of leaving temporary files behind. The architecture is centered around the TemporaryDirectory class in src/TemporaryDirectory.php, which encapsulates all functionality for temporary directory management. The class uses a fluent interface pattern, allowing method chaining for configuration. It handles edge cases such as trailing slashes in paths, invalid characters in directory names, and forceful recreation of existing directories. The deleteDirectory method includes a garbage collection call to mitigate file handle issues on Windows, demonstrating attention to cross-platform filesystem nuances. The project is actively maintained, with recent commits and regular updates to support new PHP versions. The codebase exhibits strong craftsmanship, with clear separation of concerns, proper error handling via custom exceptions, and adherence to modern PHP practices. While focused on a single responsibility, the library is highly reusable in any PHP 8+ project requiring temporary directory management, with no external dependencies beyond the PHP core.