lewagon/data-setup is a Ruby-based documentation build system that generates the Le Wagon Data Science bootcamp environment setup guides for macOS, Windows, Linux, VM, and remote setups. It reads OS-specific YAML build specifications, resolves localized markdown partials from `_partials/` (including Spanish translations and remote partials fetched from other lewagon repositories), renders them with Liquid templating, and writes final bilingual guides back to markdown files. The primary entry point is `build.rb`, orchestrated by `lib/builder.rb` and `lib/generator.rb`, with CI via GitHub Actions rebuilding and committing generated files on every push. Despite the data-science branding, this is not a data-research repository: there is no pipeline, notebook, or model code. The only data-related artifacts are pinned Python package requirement files under `specs/releases/` and environment verification scripts in `checks/`. The dominant character is an application — specifically a content-generation toolchain for setup documentation. It demonstrates a clean partial-composition model, locale-aware fallback, remote content fetching with image-path rewriting, and parallel partial caching. The repository is actively maintained and technically current, though its reliance on pinned Python versions and remote GitHub raw URLs creates an ongoing need for upkeep. It is a well-structured niche tool rather than a general-purpose framework, but its modular design makes parts of the build pipeline reusable in similar multi-source documentation projects.
ruby-nmap is a Ruby library that provides programmatic access to the nmap network scanning tool. It consists of two main components: 1) A command-line interface builder (Nmap::Command) that allows Ruby programs to configure and execute nmap scans with full access to nmap's options through a Ruby DSL, and 2) An XML parser (Nmap::XML) that converts nmap's XML output into navigable Ruby objects representing hosts, ports, services, OS detection results, and script output. The library acts as a bridge between Ruby applications and the nmap executable, handling the complexity of command-line argument construction and XML parsing while providing an idiomatic Ruby interface. The project is actively maintained with recent commits, comprehensive test coverage, and support for multiple Ruby versions.
Octobox is a self-hosted, open-source web application for managing GitHub notifications. Built as a Ruby on Rails monolith (Rails 8.1, Ruby 3.x), it syncs notifications from the GitHub API into a PostgreSQL database, providing a rich UI for filtering, archiving, muting, starring, and searching notifications. Background jobs via Sidekiq handle syncing subjects, labels, comments, and performing actions like marking notifications as read on GitHub. Real-time updates are pushed via ActionCable. The application also exposes a REST API for programmatic access and supports GitHub App and OAuth authentication. It is designed for both hosted (octobox.io) and self-hosted deployments, with Docker, Heroku, and OpenShift support. The codebase is well-tested with Minitest and system tests, and follows standard Rails conventions with some custom patterns for search parsing and API client pagination.
This is a CLI tool for installing multiple Ruby implementations (CRuby, JRuby, TruffleRuby, mruby) from source. It auto-detects the operating system, package manager, and downloader, then downloads, verifies checksums, applies patches, compiles, and installs the Ruby. The architecture is a collection of sourced bash scripts organized into a plugin system: each Ruby implementation has its own `functions.sh` and `dependencies.sh` that override generic steps. The main entry point is `bin/ruby-install`, which orchestrates the process using utility functions from `share/ruby-install/`. The codebase is well-structured with extensive test coverage using shunit2, and follows a strict coding style. It does not handle data pipelines or analytics; it is purely a system administration tool.
Quickdraw is a Ruby test framework designed to leverage multi-core systems for faster test execution. It provides its own test DSL while also offering adapters for Minitest and RSpec. The framework uses process forking to distribute tests across multiple CPU cores, with special optimizations for M-series Macs that can utilize performance or efficiency cores. Key features include watch mode for automatic test re-running, lazy error message computation to avoid slowing down tests, and scoped execution to prevent top-level method/constant collisions. The architecture consists of a CLI entry point, test runner with worker processes, assertion libraries, and platform-specific optimizations.
Stripe-ruby-mock is a Ruby library that provides in-memory mocking of the Stripe API for testing purposes. It intercepts Stripe HTTP requests and returns simulated responses, enabling offline, deterministic testing without real API keys or network access. The library supports both local mocking (via `StripeMock.start`/`stop`) and a remote mock server for integration tests across processes. It covers a wide range of Stripe endpoints including charges, customers, subscriptions, invoices, payment intents, and webhooks, with extensive shared RSpec examples and webhook fixtures. The architecture follows a modular request-handler pattern, with helpers for token generation, param validation, and search simulation. While the codebase is well-structured and popular (996 stars), it shows signs of maintenance strain (199 open issues, call for core maintainers) and technical drift (vendored Trollop CLI parser, outdated webhook fixtures, limited Stripe API version coverage). It remains a valuable tool for legacy Stripe testing but may require updates to fully align with current Stripe API changes.
This is a demo application showcasing ActiveAdmin functionality for Ruby on Rails. It provides an admin interface for managing AdminUser records with Devise authentication, featuring CRUD operations, a customizable dashboard, and proper error handling. The application follows standard Rails MVC architecture with ActiveAdmin as an engine/plugin, uses Importmap for JavaScript bundling, and CSS Bundling with TailwindCSS for styling. It includes comprehensive test coverage and is actively maintained with CI/CD pipelines.
This repository hosts a Turkish-language Ruby 101 tutorial book, designed as a beginner's guide to the Ruby programming language. The content is authored in Markdown and organized into chapters covering Ruby syntax, data types, control structures, and practical topics like RubyGems and web development with Sinatra. The book is intended to be a portable reference for learners, emphasizing practical examples and idiomatic Ruby usage. The project is structured as a static site generated using MkDocs, with the Rakefile providing convenient commands for building, serving locally, and deploying to GitHub Pages. The mkdocs.yml configuration defines a hierarchical navigation structure, integrates the Material theme, and enables extensions for features like table of contents, syntax highlighting, and tabbed content. Dependencies are pinned in requirements.txt to ensure reproducible builds. While the documentation content reflects Ruby versions up to 3.0.2 (as of 2021), the underlying tooling remains functional and the project demonstrates maintenance through a 2026 commit history. The Rakefile represents a reusable pattern for MkDocs projects, encapsulating the common tasks of building, serving, and deploying documentation with minimal configuration. This wrapper allows developers to leverage MkDocs' capabilities without repeating command-line invocations, promoting consistency across documentation projects. The configuration file mkdocs.yml exemplifies effective use of MkDocs' features for structuring a multi-chapter book, including custom navigation and extension integration, though it is tailored to this specific book's organization.
Maid is a Ruby command-line tool and library that automates file organization and cleanup based on user-defined rules expressed in a Ruby DSL. It provides a suite of operations (move, trash, copy, rename, etc.) that can be combined with file metadata predicates (age, size, content type, download source, etc.) to systematically manage filesystems. The architecture is a traditional Ruby gem with a Thor-based CLI (bin/maid), a central Maid::Maid class that orchestrates rule loading and execution, and a set of tool methods mixed into the Maid instance for use in rule blocks. It also supports daemon mode using Listen (file system watcher) and rufus-scheduler (timed repeats). The code is well-structured with modular components, extensive test coverage, and modern Ruby practices, though it carries some legacy from supporting older Ruby versions. There is no data research or analytic component; it is purely an application for file automation.
SequenceServer is a Ruby/Sinatra web application that provides a graphical interface for running NCBI BLAST+ and DIAMOND sequence similarity searches against custom databases. It manages BLAST database formatting, job submission with background execution, result parsing, and interactive visualization of alignments using D3.js and Circos-style plots. The backend uses a thread pool for concurrent job processing, YAML-based job persistence, and a plugin system for extensibility. The frontend is built with React and includes components for database selection, query input, and result exploration with export to SVG/PNG. The application is designed for bioinformatics researchers who need a self-hosted BLAST server with a modern web UI, supporting multiple BLAST programs (blastn, blastp, blastx, tblastn, tblastx) and DIAMOND. It includes comprehensive test suites for multiple BLAST versions and CI/CD pipelines for Docker and AppImage deployment.
Timeasure is a Ruby gem for transparent method-level runtime profiling in production environments. It uses `Module#prepend` and metaprogramming to intercept method calls on classes and modules that include the `Timeasure` module, measuring execution time via `Process.clock_gettime(Process::CLOCK_MONOTONIC)`. The gem provides class macros (`tracked_instance_methods`, `tracked_class_methods`, etc.) to declare which methods to profile, and a direct `Timeasure.measure` interface for manual instrumentation. Measurements are aggregated by method path (class and method name) and optionally segmented by custom values, stored in an in-memory `ReportedMethodsHandler`, and exported via `Timeasure::Profiling::Manager.export`. The architecture is a simple library with configurable procs for post-measurement handling and error rescue, allowing users to integrate with external services like New Relic or Keen.io. The codebase is small, well-tested, and cleanly structured, but has not been updated since 2018, leading to outdated dependencies and a Ruby version target of 2.1+.
Tilt is a Ruby library that provides a generic interface to a multitude of template engines. It abstracts away the differences between engines like ERB, Haml, Markdown variants, and many others, offering a unified API for template loading, compilation, and rendering. The architecture is built around a central Tilt module, a Mapping class that associates file extensions with template implementations, and a base Template class that individual engines subclass. The library supports lazy loading of template engines, template caching, and pipeline composition. It is widely used in the Ruby ecosystem, particularly in web frameworks like Sinatra and Rack. The repository under rtomayko/tilt is no longer maintained, as the project has moved to jeremyevans/tilt, but this version represents the stable 2.x series. The code is well-structured and demonstrates good software engineering practices, though some template implementations are deprecated or rely on older gems.
Rerun is a command-line utility that automatically restarts a program when relevant files in a watched directory change. It wraps the Listen gem to efficiently monitor the filesystem and supports graceful process termination via configurable signal sequences (default TERM, INT, KILL). The tool provides real-time keypress commands (restart, force restart, clear, pause, quit) and optional desktop notifications via growlnotify, terminal-notifier, or notify-send. The codebase is a single Ruby gem with a CLI entry point (bin/rerun) and a clear separation of concerns: Runner for process management, Watcher for filesystem listening, Options for CLI parsing, and Notification for cross-platform alerts. It was last actively developed around 2014-2018, with a documented version 0.14.0 in 2023, but open issues and pull requests from 2014 suggest it is no longer maintained.
This repository is a thin meta-gem that serves as a convenience wrapper for `rspec-parameterized-core` and `rspec-parameterized-table_syntax`. It provides no implementation of its own—the actual parameterized test logic (table syntax, lazy evaluation, `ref`, `with_them`, etc.) lives in the upstream gems. The code here consists of a gemspec, a version file, and a single require chain. The spec file demonstrates all supported syntaxes (nested arrays, hashes, verbose, table syntax, custom names, `ref`/`lazy`) but relies entirely on the upstream gems to execute. The repository is actively maintained with recent commits, CI across multiple Ruby versions, and automated release workflows. It is a standard Ruby gem with no unusual architecture or reusable internal components; its value is purely in bundling the two dependent gems for easier installation.
This repository is an 'awesome list' of open-source macOS applications. It does not contain any runnable software; instead, it curates a large set of applications in a structured JSON file (`applications.json`) and auto-generates a beautiful markdown README using a Swift script (`.github/main.swift`). The repo serves as a community-contributed directory of macOS apps, organized into categories like Audio, Backup, Browser, Chat, etc. The core value is the human-curated data in `applications.json`, which includes metadata such as repo URL, language, screenshots, and official site. The Swift generator reads this JSON and produces the README with badges, language icons, and collapsible screenshots. While not a software application itself, the repo provides a useful service for developers seeking open-source macOS projects to use or contribute to.
Ruote is a mature Ruby workflow engine (BPM) that orchestrates long-running business processes through a tree of expressions (sequence, concurrence, if, participant, etc.). The engine routes workitems to registered participants, persists process state via pluggable storage backends (in-memory, file system, composite), and supports process definitions in Ruby DSL, XML, JSON, and a custom Radial format. It provides a full API via Ruote::Dashboard for launching, canceling, pausing, and inspecting processes, along with error handling, timers, observers, and cross-process communication via await/listen. The codebase is well-structured with a clear expression lifecycle, participant abstraction, and a service-oriented architecture. However, the project is explicitly deprecated—the README states 'Do not involve ruote in your new project' and directs users to the successor flor. Development ceased around 2013, and the code relies on outdated Ruby idioms and dependencies (e.g., sourcify, parslet 1.4.0), making it unsuitable for modern Ruby projects without significant adaptation.
This repository is a community-driven collection of programming exercise solutions, organized as a numbered roadmap (00 to 50) covering fundamental to intermediate topics. Each exercise is solved in multiple programming languages (Python, JavaScript, Java, C++, Go, Kotlin, etc.) by different contributors. The code consists of standalone scripts that demonstrate language features such as recursion, data structures, exception handling, async programming, regular expressions, design patterns (Singleton, Decorator), and SOLID principles. The repository is not a cohesive application or library; it is an educational resource for learning and practicing programming concepts across languages. The quality of solutions varies widely, with some files containing errors or being incomplete. The project relies on community contributions and lacks centralized testing or dependency management.
This repository is a curated list of interesting open source projects organized by programming language. It contains markdown files with links and descriptions for each language. There is no application code, data pipelines, or analytical models. It serves as a reference directory for developers seeking open source projects to contribute to or learn from. The repository is well-maintained with recent updates and a large community following.