vehicles ships a curated, bundled dataset of car makes and models (with kind and body type) and a delightful, Rails-friendly API for vehicle dropdowns, search, and validation. No API keys, no network calls, no database table — the data lives inside the gem and just works. It also acts as the SDK for the hosted VehiclesDB API. Code is MIT; the bundled data is CC-BY 4.0 (derived from RDW Open Data).
A mountable Rails engine providing a complete data import workflow: upload/configure, preview with validation, and import. Supports CSV, JSON, XLSX, and API sources with a simple DSL for defining import targets.
Idiomatic Ruby client for the VoiceTel REST API: provision numbers, place orders, validate e911, send SMS/MMS, manage 10DLC campaigns, and run support tickets, all with typed Data models, structured errors, and automatic retry on 429/5xx.
A YAML-based schema system for validating and transforming configuration data
This filter helps to verify if the given JSON data is valid with JSON schema
Provides Students_list_YAML class for managing student data with YAML persistence. Includes support for student records with validation, sorting, and pagination.
FX rates are read from an XML file and stored locally into a hash map. Then FX rate between two selected currencies is calculated for a given date. There are checks about data validity, such as date and currency format.
Drop-in Rails engine that patches link_to to block dangerous protocols (javascript:, data:, vbscript:) and provides a URL validator to prevent SSRF via private/local IP resolution.
Comprehensive CLI tool for managing Strata Semantic Analytics projects. Create and initialize projects, manage datasource connections, build semantic table models with AI assistance, run audits and validations, and deploy projects to Strata servers. Supports multiple data warehouse adapters including PostgreSQL, MySQL, SQL Server, Snowflake, BigQuery, Athena, Trino, ClickHouse, and more.
A DSL for building matchers that validate nested data structures. Ruby literals like classes, ranges, regexps, arrays, and hashes are automatically converted into matchers. Mismatches produce error trees with paths pointing to each failing element.
Developed by Sebastian Madrid Ontiveros. Pure Ruby gem providing all Ordnance Survey British National Grid squares (100km, 50km, 10km, 5km, 1km) with hardcoded geometry sourced directly from the OS BNG Grids GeoPackage. Supports point-to-grid-ref lookup by easting/northing, bounds retrieval, grid square validation, listing with filters, and export to ESRI Shapefile format. No external dependencies. Uses only Ruby stdlib. Contains OS data. Crown copyright and database right 2025. Licensed under the Open Government Licence v3.0. Built to support hydraulic modelling and flood risk workflows in the UK. If this gem saves you time, consider buying Sebastian a coffee at https://buymeacoffee.com/smadrid
A library of tested, documented regex patterns for common data formats. Includes named captures, validation helpers, and extraction methods.
Rbdantic provides BaseModel-like data classes with field validation, type coercion, custom validators, JSON Schema generation, and serialization. Inspired by Python's Pydantic.
Define data classes with typed fields, default values, validation rules, and pattern matching support. Immutable by default with keyword-only construction, JSON/Hash serialization, and runtime type checking.
Validate Ruby data structures against JSON Schema definitions with support for type checking, required properties, pattern matching, numeric ranges, enums, and array validation.
rails-ai-context turns your running Rails app into the source of truth for AI coding assistants. Instead of guessing from training data or stale file reads, agents query 35 live tools (via MCP server or CLI) to get your actual schema, associations, routes, inherited filters, conventions, and test patterns. Semantic validation catches cross-file errors (wrong columns, missing partials, broken routes) before code runs - so AI writes correct code on the first try. Auto-generates context files for Claude Code, Cursor, GitHub Copilot, OpenCode, and Codex CLI. Works standalone or in-Gemfile.
Flexible and type-safe representation of JSON data.
A zero-dependency Ruby gem for transforming data between formats with a mapping DSL, field renaming, type conversion, validation, and CSV support.
A zero-dependency Ruby gem for validating hash data against schemas with type checking, coercion, required/optional fields, and custom validators.
A Rails gem that provides Japanese address completion and validation based on Japan Post postal code CSV data. Supports address lookup by postal code, prefix search, and address/postal code consistency validation.
Daily-checked European VAT rates with standard and reduced rate types, offline access, local VAT metadata, and VAT number format validation.
Rkwalify is a parser, schema validator, and data binding tool for YAML and JSON. Rkwalify enables you to handle YAML and JSON more easily and strictly.
AiGuardrails is a Ruby gem that helps developers validate, correct, and enforce schemas on AI-generated outputs. It ensures structured data, prevents JSON errors, and provides a foundation for adding safety filters and auto-correction in Rails apps, CLI tools, background jobs, and scrapers. Think of it as Guardrails.AI for Ruby.
Framework for building business operations as composable pipelines. Chain steps that short-circuit on failure, collect validation errors, wrap in database transactions with callbacks, and scope nested data structures.
A Jekyll plugin that automatically generates and validates domain-profile.json files according to the AI Domain Data Standard v0.1.1. The plugin creates the file at .well-known/domain-profile.json during site generation and provides Liquid tags for accessing domain data in your templates.
Expectant provides a clean DSL for defining multiple validation schemas in a single class. Built on dry-validation and dry-types, it supports custom rules, defaults, fallbacks, and context-aware validations, making it easy to validate inputs, outputs, and any structured data in your Ruby applications.
Instead of scattering validations, strong parameters, and business rules across controllers and models, changesets give you one clear interface for handling data before it touches the database.
A Ruby gem that provides geographic lookup functionality using both GeoBoundaries.org and Geonames.org datasets. Features include coordinate validation with radian/degree detection, spatial containment queries, distance-based lookups, and data coverage analysis utilities.
Poti is a simple and declarative Ruby gem for data validation and organization
poty is a simple and declarative Ruby gem for data validation and organization
opala is a simple and declarative Ruby gem for data validation and organization
cajuina is a simple and declarative Ruby gem for data validation and organization
GRYDRA v2.0 is a complete, modular Ruby library for building, training, and deploying neural networks. NEW in v2.0: - Complete modular architecture with 29 organized files - Keyword arguments API for better readability - Full implementations (no more "simplified" versions) - 8 loss functions (MSE, MAE, Huber, Cross-Entropy, Hinge, Log-Cosh, Quantile) - 5 optimizers (Adam, SGD, RMSprop, AdaGrad, AdamW) - 6 training callbacks (EarlyStopping, LearningRateScheduler, ReduceLROnPlateau, ModelCheckpoint, CSVLogger, ProgressBar) - Complete LSTM implementation with backpropagation - Complete 2D Convolutional layer with padding and stride - Real PCA with eigenvalue decomposition using Power Iteration - Multiple activation functions (Tanh, ReLU, Leaky ReLU, Sigmoid, Swish, GELU, Softmax) - Regularization (Dropout, L1, L2) - Weight initialization (Xavier, He) - Data normalization (Z-Score, Min-Max) - Comprehensive metrics (MSE, MAE, Accuracy, Precision, Recall, F1, Confusion Matrix, AUC-ROC) - Advanced training (mini-batch, early stopping, learning rate decay, validation split) - Cross-validation and hyperparameter search - Text processing (vocabulary, binary vectorization, TF-IDF) - Model persistence (save/load with Marshal) - Network visualization and gradient analysis - Simplified EasyNetwork interface - 100% backward compatibility with v1.x Perfect for machine learning projects, research, and education in Ruby.
GuideRail transforms various data sources into safe, immutable `Data` objects. By leveraging the robust validation capabilities of `dry-schema`, it provides a clear and declarative way to define, validate, and instantiate your data structures.
A comprehensive Ruby client for interacting with the Rospatent patent search API. Features include automatic caching, request validation, structured logging, error handling, and batch operations for efficient patent data retrieval.
This gem supplies a `fa` executable which can create, read, update and delete data using the Freeagent API. You need to specify valid Freeagent app credentials. Generate a Freeagent app at https://dev.freeagent.com/apps. Ensure you set 'http://localhost:*/' as a valid OAuth redirect URI. Then export your ID and secret as environment variables FREEAGENT_APP_ID and FREEAGENT_APP_SECRET. On first run, `fa` will authenticate you via OAuth so watch out for an authentication URI printed to the console.
Castkit is a lightweight, type-safe Ruby DSL for defining, validating, and serializing structured data objects. Inspired by DTO patterns, it supports nested types, access control, custom serializers, and more.
Automatically infer and create Ruby Struct-like classes from arbitrary data sources with runtime type validation
A data validation library providing a rule-based schema definition language. For checking (incoming) data against a specified schema definition. GDS stands for General Data Structure.
Defines the skills cards data model and methods to validate whether given data matches this model.
DbValidator helps identify invalid records in your Rails application that don't meet model validation requirements. It finds records that became invalid after validation rule changes, and validates imported or manually edited data. You can use it to audit records before deploying new validations and catch any data that bypassed validation checks.
This is a simple machine learning library written in Ruby. It provides implementations of linear regression and multiclass perceptron and visualization and validation methods to verify results. Also included are helper methods to work with training and testing data.
This is an improved input function for Ruby. Using this gem, you can easily get user input with real-time type validation, ensuring that the data provided is as expected, among other things. If you have any questions, check the documentation: https://github.com/barrosflavio/ruby_better_input Features: - Ask, receive and check input in a single line - Support for types such as integer, float and boolean. - Input validation with clear error messages. - Intuitive and easy-to-use function.
The DynamicSchema gem provides a elegant and expressive way to define a domain-specific language (DSL) schemas, making it effortless to build and validate complex Ruby hashes. This is particularly useful when dealing with intricate configurations or interfacing with external APIs, where data structures need to adhere to specific formats and validations. By allowing default values, type constraints, nested schemas, and transformations, DynamicSchema ensures that your data structures are both robust and flexible. New in 2.0, DynamicSchema adds DynamicSchema::Struct which faciliates effortless definition and construction of complex object hierarchies, with optional type coersion and validation. Where DynamicSchema simplified configuration and API payload construction, DynamicSchema::Struct simplifies construction of complex API reponses.
AdaptiveConfiguration is an elegant, lightweight and simple, yet powerful Ruby gem that allows you to define a DSL (Domain-Specific Language) for structured and hierarchical configurations. It is ideal for defining complex configurations for various use cases, such as API clients, application settings, or any scenario where structured configuration is needed. In addition AdaptiveConfiguration can be more generally used to transform and validate JSON data from any source such as from a network request or API reponse.
The auto_seeder gem generates random, valid data for Rails models using Faker. It can seed data for multiple models, handle associations and respect validations.
Bed is a simple, modern schema library built on top of Data. It provides a simple, declarative way to define schemas for your data, and a way to validate that data against those schemas.
ServiceCore provides a four-key response contract (status, data, message, errors) for service objects, with field declarations, validations, step validation, structured logging, and a Hash-compatible Response value object.
Data structures, validation, coercion and processing toolkit for Ruby
# Quick Start The Owner API uses the JSON format, and must be accessed over a [secure connection](https://en.wikipedia.org/wiki/HTTPS). Let’s assume that the access token provided by your account manager is “TOKEN”. Here’s how to get the list of ids of all your invoices from the first week of August with a shell script: ```bash query="end_date=2018-08-08T00%3A00%3A00%2B00%3A00&start_date=2018-08-01T00%3A00%3A00%2B00%3A00" curl -i "https://api-eu.getaround.com/owner/v1/invoices?${query}" \ -H "Authorization: Bearer TOKEN" \ -H "Accept:application/json" \ -H "Content-Type:application/json" ``` And here’s how to get the invoice with the id 12345: ```bash curl -i "https://api-eu.getaround.com/owner/v1/invoices/12345" \ -H "Authorization: Bearer TOKEN" \ -H "Accept: application/json" \ -H "Content-Type: application/json"" ``` See the [endpoints section](#tag/Invoices) of this guide for details about the response format. Dates in request params should follow the ISO 8601 standard. # Authentication All requests must be authenticated with a [bearer token header](https://tools.ietf.org/html/rfc6750#section-2.1). You token will be sent to you by your account manager. Unauthenticated requests will return a 401 status. # Pagination The page number and the number of items per page can be set with the “page” and “per_page” params. For example, this request will return the second page of invoices, and 50 invoices per page: `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` Both of these params are optional. The default page size is 30 items. The Getaround Owner API follows the [RFC 8288 convention](https://datatracker.ietf.org/doc/html/rfc8288) of using the `Link` header to provide the `next` page URL. Please don't build the pagination URLs yourself. The `next` page will be missing when you are requesting the last available page. Here's an example response header from requesting the second page of invoices `https://api-eu.getaround.com/owner/v1/invoices?page=2&per_page=50` ``` Link: <https://api-eu.getaround.com/owner/v1/invoices?page=3&per_page=50>; rel="next" ``` # Throttling policy and Date range limitation We have throttling policy that prevents you to perform more than 100 requests per min from the same IP. Also, there is a limitation on the size of the range of dates given in params in some requests. All requests that need start_date and end_date, do not accept a range bigger than 30 days. # Webhooks Getaround can send webhook events that notify your application when certain events happen on your account. This is especially useful to follow the lifecycle of rentals, tracking for example bookings or cancellations. ### Setup To set up an endpoint, you need to define a route on your server for receiving events, and then <a href="mailto:owner-api@getaround.com">ask Getaround</a> to add this URL to your account. To acknowledge receipt of a event, your endpoint must: - Return a `2xx` HTTP status code. - Be a secure `https` endpoint with a valid SSL certificate. ### Testing Once Getaround has set up the endpoint, and it is properly configured as described above, a test `ping` event can be sent by clicking the button below: <form action="/docs/api/owner/fire_ping_webhook" method="post"><input type="submit" value="Send Ping Event"></form> You should receive the following JSON payload: ```json { "data": { "ping": "pong" }, "type": "ping", "occurred_at": "2019-04-18T08:30:05Z" } ``` ### Retries Webhook deliveries will be attempted for up to three days with an exponential back off. After that point the delivery will be abandoned. ### Verifying Signatures Getaround will also provide you with a secret token, which is used to create a hash signature with each payload. This hash signature is passed along with each request in the headers as `X-Drivy-Signature`. Suppose you have a basic server listening to webhooks that looks like this: ```ruby require 'sinatra' require 'json' post '/payload' do push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end ``` The goal is to compute a hash using your secret token, and ensure that the hash from Getaround matches. Getaround uses an HMAC hexdigest to compute the hash, so you could change your server to look a little like this: ```ruby post '/payload' do request.body.rewind payload_body = request.body.read verify_signature(payload_body) push = JSON.parse(params[:payload]) "I got some JSON: #{push.inspect}" end def verify_signature(payload_body) signature = 'sha1=' + OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha1'), ENV['SECRET_TOKEN'], payload_body) return halt 500, "Signatures didn't match!" unless Rack::Utils.secure_compare(signature, request.env['HTTP_X_DRIVY_SIGNATURE']) end ``` Obviously, your language and server implementations may differ from this code. There are a couple of important things to point out, however: No matter which implementation you use, the hash signature starts with `sha1=`, using the key of your secret token and your payload body. Using a plain `==` operator is not advised. A method like secure_compare performs a "constant time" string comparison, which renders it safe from certain timing attacks against regular equality operators. ### Best Practices - **Acknowledge events immediately**. If your webhook script performs complex logic, or makes network calls, it’s possible that the script would time out before Getaround sees its complete execution. Ideally, your webhook handler code (acknowledging receipt of an event by returning a `2xx` status code) is separate of any other logic you do for that event. - **Handle duplicate events**. Webhook endpoints might occasionally receive the same event more than once. We advise you to guard against duplicated event receipts by making your event processing idempotent. One way of doing this is logging the events you’ve processed, and then not processing already-logged events. - **Do not expect events in order**. Getaround does not guarantee delivery of events in the order in which they are generated. Your endpoint should therefore handle this accordingly. We do provide an `occurred_at` timestamp for each event, though, to help reconcile ordering.