Data Validation

A multi-context configuration library and DSL. ReferenceBook provides an easy interface to define, validate and query multi-context configuration data.

A composable application toolkit, providing data entities and collections, transforms, contract-based validations and pre-built operations. Architecture agnostic for easy integration with other toolkits or frameworks.

Keep your data pukka with these custom ActiveModel validators.

Implements in-app purchase data parsing, signature validation,

A Ruby library to describe the types of your data and ways to validate them.

Provides data class validation for active-model objects

A simple Gem to enable any `ActiveRecord::Base` object to store a set of attributes in a set like structure represented through a bitfield on the database level. You only have to specify the name of the set to hold the attributes in question an the rest is done for you through some fine selected Ruby magic. Here is a simple example of how you could use the gem: class Person < ActiveRecord::Base has_set :interests end To get this to work you need some additional work done first: 1. You need an unsigned 8-Byte integer column in your database to store the bitfield. It is expected that the column is named after the name of the set with the suffix `_bitfield` appended (e.g. `interests_bitfield`). You can change that default behavior by providing the option `:column_name` (e.g. `has_set :interests, :column_name => :my_custom_column`). 2. You need a class that provides the valid values to be stored within the set and map the single bits back to something meaningful. The class should be named after the name of the set (you can change this through the `:enum_class` option). This class could be seen as an enumeration and must implement the following simple interface: * There must be a class method `values` to return all valid enumerators in the defined enumeration. * Each enumerator must implement a `name` method to return a literal representation for identification. The literal must be of the type `String`. * Each enumerator must implement a `bitfield_index` method to return the exponent of the number 2 for calculation the position of this enumerator in the bitfield. **Attention** Changing this index afterwards will destroy your data integrity. Here is a simple example of how to implement such a enumeration type while using the the `renum` gem for simplicity. You are free to use anything else that matches the described interface. enum :Interests do attr_reader :bitfield_index Art(0) Golf(1) Sleeping(2) Drinking(3) Dating(4) Shopping(5) def init(bitfield_index) @bitfield_index = bitfield_index end end

Kwalify is a parser, schema validator, and data binding tool for YAML and JSON.

ActiveModel-compliant form objects for rails app. Forms have data and behavior. Let them be the objects they want to be. Plus, get presentation- specific validation logic out of your models.

The renavam validator is a simple and small data validator for Brazilian vehicle documents.

Validates a StepLib datastore (usually stored in JSON) data. This GEM's major and minor version number matches the related StepLib format specification's major and minor version number.

ErrorProne lets you choose where, when, and how to validate data without tying you to ORMs or application frameworks.

Simple DSL for datatype validation for basic data types.Inspired from GRPC DSL. Since ruby is dynamic language, datatype validator helps to reduce runtime errors by validating structure before processing

This gem provides a way to easily specify methods that an object must implement, as well as a way to validate that required methods exist. In addition, you can specify additional information about the interface of your object that can be used to produce documentation. Specifically you can specify the return type of your methods, as well as the method's arguments and argument return types. The data types are not enforced, but can be viewed by running `MyClass.interface.print`.

VAT Identification Number data object and validator

Define a DSL in Ruby to validate and access any data

A JSON parser/generator that conforms (I believe) to RFC8259 "The JavaScript Object Notation (JSON) Data Interchange Format". This gem honors the syntax as possible. The generator guarantees that a parsed valid properly rounds-trip to identical valid JSON representation.

A ruby interface over the DataValidation service.

Allows you to interact with the verifi.io API. Validate your data.

Small and extensible data validation toolkit

The Tripletex API is a **RESTful API**, which does not implement PATCH, but uses a PUT with optional fields. **Actions** or commands are represented in our RESTful path with a prefixed `:`. Example: `/v2/hours/123/:approve`. **Summaries** or aggregated results are represented in our RESTful path with a prefixed <code>&gt;</code>. Example: <code>/v2/hours/&gt;thisWeeksBillables</code>. **"requestID"** is a key found in all validation and error responses. If additional log information is absolutely necessary, our support division can locate the key value. **Download** the [swagger.json](/v2/swagger.json) file [OpenAPI Specification](https://github.com/OAI/OpenAPI-Specification) to [generate code](https://github.com/sveredyuk/tripletex_ruby). This document was generated from the Swagger JSON file. **version:** This is a versioning number found on all DB records. If included, it will prevent your PUT/POST from overriding any updates to the record since your GET. **Date & DateTime** follows the **ISO 8601** standard. Date: `YYYY-MM-DD`. DateTime: `YYYY-MM-DDThh:mm:ssZ` **Sorting** is done by specifying a comma separated list, where a `-` prefix denotes descending. You can sort by sub object with the following format: `project.name, -date`. **Searching:** is done by entering values in the optional fields for each API call. The values fall into the following categories: range, in, exact and like. **Missing fields or even no response data** can occur because result objects and fields are filtered on authorization. **See [FAQ](https://tripletex.no/execute/docViewer?articleId=906&language=0) for more additional information.** ## Authentication: - **Tokens:** The Tripletex API uses 3 different tokens - **consumerToken**, **employeeToken** and **sessionToken**. - **consumerToken** is a token provided to the consumer by Tripletex after the API 2.0 registration is completed. - **employeeToken** is a token created by an administrator in your Tripletex account via the user settings and the tab "API access". Each employee token must be given a set of entitlements. [Read more here.](https://tripletex.no/execute/docViewer?articleId=853&language=0) - **sessionToken** is the token from `/token/session/:create` which requires a consumerToken and an employeeToken created with the same consumer token, but not an authentication header. See how to create a sessionToken [here](https://tripletex.no/execute/docViewer?articleId=855&language=0). - The session token is used as the password in "Basic Authentication Header" for API calls. - Use blank or `0` as username for accessing the account with regular employee token, or if a company owned employee token accesses <code>/company/&gt;withLoginAccess</code> or <code>/token/session/&gt;whoAmI</code>. - For company owned employee tokens (accounting offices) the ID from <code>/company/&gt;withLoginAccess</code> can be used as username for accessing client accounts. - If you need to create the header yourself use <code>Authorization: Basic &lt;base64encode('0:sessionToken')&gt;</code>. ## Tags: - <div class="tag-icon-beta"></div> **[BETA]** This is a beta endpoint and can be subject to change. - <div class="tag-icon-deprecated"></div> **[DEPRECATED]** Deprecated means that we intend to remove/change this feature or capability in a future "major" API release. We therefore discourage all use of this feature/capability. ## Fields: Use the `fields` parameter to specify which fields should be returned. This also supports fields from sub elements. Example values: - `project,activity,hours` returns `{project:..., activity:...., hours:...}`. - just `project` returns `"project" : { "id": 12345, "url": "tripletex.no/v2/projects/12345" }`. - `project(*)` returns `"project" : { "id": 12345 "name":"ProjectName" "number.....startDate": "2013-01-07" }`. - `project(name)` returns `"project" : { "name":"ProjectName" }`. - All elements and some subElements : `*,activity(name),employee(*)`. ## Changes: To get the changes for a resource, `changes` have to be explicitly specified as part of the `fields` parameter, e.g. `*,changes`. There are currently two types of change available: - `CREATE` for when the resource was created - `UPDATE` for when the resource was updated NOTE: For objects created prior to October 24th 2018 the list may be incomplete, but will always contain the CREATE and the last change (if the object has been changed after creation). ## Rate limiting in each response header: Rate limiting is performed on the API calls for an employee for each API consumer. Status regarding the rate limit is returned as headers: - `X-Rate-Limit-Limit` - The number of allowed requests in the current period. - `X-Rate-Limit-Remaining` - The number of remaining requests. - `X-Rate-Limit-Reset` - The number of seconds left in the current period. Once the rate limit is hit, all requests will return HTTP status code `429` for the remainder of the current period. ## Response envelope: ``` { "fullResultSize": ###, "from": ###, // Paging starting from "count": ###, // Paging count "versionDigest": "Hash of full result", "values": [...list of objects...] } { "value": {...single object...} } ``` ## WebHook envelope: ``` { "subscriptionId": ###, "event": "object.verb", // As listed from /v2/event/ "id": ###, // Object id "value": {... single object, null if object.deleted ...} } ``` ## Error/warning envelope: ``` { "status": ###, // HTTP status code "code": #####, // internal status code of event "message": "Basic feedback message in your language", "link": "Link to doc", "developerMessage": "More technical message", "validationMessages": [ // Will be null if Error { "field": "Name of field", "message": "Validation failure information" } ], "requestId": "UUID used in any logs" } ``` ## Status codes / Error codes: - **200 OK** - **201 Created** - From POSTs that create something new. - **204 No Content** - When there is no answer, ex: "/:anAction" or DELETE. - **400 Bad request** - - **4000** Bad Request Exception - **11000** Illegal Filter Exception - **12000** Path Param Exception - **24000** Cryptography Exception - **401 Unauthorized** - When authentication is required and has failed or has not yet been provided - **3000** Authentication Exception - **9000** Security Exception - **403 Forbidden** - When AuthorisationManager says no. - **404 Not Found** - For content/IDs that does not exist. - **6000** Not Found Exception - **409 Conflict** - Such as an edit conflict between multiple simultaneous updates - **7000** Object Exists Exception - **8000** Revision Exception - **10000** Locked Exception - **14000** Duplicate entry - **422 Bad Request** - For Required fields or things like malformed payload. - **15000** Value Validation Exception - **16000** Mapping Exception - **17000** Sorting Exception - **18000** Validation Exception - **21000** Param Exception - **22000** Invalid JSON Exception - **23000** Result Set Too Large Exception - **429 Too Many Requests** - Request rate limit hit - **500 Internal Error** - Unexpected condition was encountered and no more specific message is suitable - **1000** Exception

Provides a concise DSL to map, validate and import data from an excel sheet into your ruby app

Drawght v1.1.0 (2025-12-22) Drawght is a data handler for texts without logical statements. The goal is to use a dataset (such as the subject of a text) to draft a document template. It can be considered a mini template processor. Latest changes: - Syntax validation. - Refined extension methods have been moved to their respective modules. - Syntax for getting the length of a collection.

TypedAttrs integrates Sorbet's T::Struct with ActiveRecord's JSON/JSONB columns, providing type-safe structured data storage with runtime and static type checking. Supports nested structs, arrays, hashes, union types, and automatic validation.

Multistep form concept for Rails projects. Allows to create complex forms for a few models simultaneously. Supports selectable per step validations without data persistence into db.

Ask for data in plain English; get validated, parameterized SQL with guardrails.

A project that is an attempt to rehabilitate and generalize a data ingestion/importation service originally built for a retail, e-commerce platform. It aims to provide a robust solution for mapping intermediate representations of database records (CSV at the moment) to persisted data. The process allows simulation, validation, and control of the arrangement of the final data form. The ultimate goal is a project that is flexible enough to use in a pure-Ruby, Rails, or standalone application backed by data storage of your choice (as long as model representations can be accessed via Ruby).

Simple solution for validate all data in database

Gem for validating and serializing data

Rails' default update_attributes behavior is that when any validation fails, none of the data gets saved. However, in some instances this is not the most ideal behavior. If you import partial data which users then have the task of completing, not saving partially completed forms can create a really negative user experience and decrease overall completion (or conversion) rates. This gem encapsulates the logic I've used to ensure that partially completed forms still persist.

The `password_auth` gem provides a simple and secure way to handle password authentication in Ruby applications. It offers a set of reusable components and utilities to handle user passwords, including password hashing, salting, and validation. Key Features: - Secure password storage: The gem uses industry-standard techniques, such as bcrypt hashing and salt generation, to securely store user passwords. - Password validation: It provides convenient methods to validate the strength and complexity of user passwords, ensuring they meet specific criteria. - Password encryption: Easily encrypt passwords for storage or comparison purposes, protecting sensitive user data. - Password reset functionality: Includes utilities for generating and handling password reset tokens, enabling users to securely reset their passwords. - Integration with popular frameworks: Seamlessly integrates with Ruby on Rails, Sinatra, and other Ruby frameworks, making it easy to incorporate password authentication into your application. By using the `password_auth` gem, developers can implement robust password authentication functionality in their Ruby applications with minimal effort, ensuring the security and integrity of user passwords.

# Foxtrot Ruby Client Library This is the Ruby client library for interacting with the Foxtrot API. The only endpoint currently exposed is the route optimization endpoint (`Foxtrot::Client.optimize!`). In order to make requests, you need a valid API key. Your API key can be found at the bottom of any page in the [Foxtrot web app](http://app.foxtrot.io/). ## Installation `gem install foxtrot-client` ## Usage ```ruby data = { file_url: "https://www.domain.io/your_file.xlsx", file_name: "your_file.xlsx", geocode: "false", stop_name: "Customer", lat: "Lat", lng: "Long", load: "Load", service_time: "Service Time", time_window: "Time Window", extra_info: "Contact Info", date_starting: "1407712069593", warehouse: "77 Massachusetts Ave, Cambridge MA", num_drivers: 1, num_avg_service_time: 10, float_fuel_cost: 3.56, float_driver_wage: 6.01, float_mpg: 8.32 } api_key = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx' require 'foxtrot' fox = Foxtrot::Client.new api_key resp = fox.optimize!(data).poll_and_block! result = resp.get_result ```

DataMapper plugin for performing validations on data models

E11y (Easy Telemetry) - Observability for Rails developers who hate noise. UNIQUE FEATURES: • Request-scoped debug buffering - buffers debug logs in memory, flushes ONLY on errors • Zero-config SLO tracking - automatic Service Level Objectives for HTTP endpoints and jobs • Schema-validated events - catch bugs before production with dry-schema DEVELOPER EXPERIENCE: • Minimal setup — one config block, works with stdout out of the box • Auto-metrics from events (no manual Yabeda.increment) • Rails-first design (follows Rails conventions) • Pluggable adapters (Loki, Sentry, OpenTelemetry, custom backends) COST SAVINGS: • Reduce log storage costs by 90% (request-scoped buffering) • Replace expensive APM SaaS ($500-5k/month → infra costs only) • Own your observability data (no vendor lock-in) PRODUCTION-READY: • Thread-safe for multi-threaded Rails + Sidekiq • Adaptive sampling (error-based, load-based, value-based) • PII filtering (GDPR-compliant masking/hashing) • Performance optimized (hash-based events, minimal allocations) Perfect for Rails 7.0+ teams who need observability without complexity or high costs.

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.

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, Athena, Trino, 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.

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 38 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.