solnic/virtus
Virtus
Virtus is a Ruby attribute management and data coercion library used to define object schemas with typed attributes. It functions as a tool for transforming nested JSON structures and complex input formats into structured internal Ruby data types.
The project provides a framework for creating value objects that are compared by their attribute values rather than memory identity. It allows for the mapping of complex external data into domain objects and supports the implementation of custom coercion logic to ensure data consistency.
The library covers data modeling through schema-driven attribute definitions and type casting. It includes capabilities for strict type validation to enforce data integrity and writer-access control to restrict the modification of an object's internal state.
Features
- Attribute Management Libraries - Provides a comprehensive system for defining object schemas with typed attributes and controlled writer access.
- Object Schema Definitions - Implements a system for defining object properties with explicit types to ensure structured interface definitions.
- Typed Object Attributes - Assigns specific types to attributes to create a structured schema and ensure data consistency.
- Data Type Coercion - Allows the implementation of custom coercion logic to transform specific input formats into target data types.
- API-to-Domain Mapping - Transforms complex external data and nested JSON structures into structured internal domain objects.
- Attribute Value Converters - Converts input values into target types automatically during the assignment of values to class attributes.
- User-Defined Types - Enables the definition of custom data types for attributes to maintain consistent data structures.
- Type Validity Enforcers - Triggers exceptions when an input value cannot be converted into the defined attribute type to ensure integrity.
- Strict Type Enforcement - Enforces data integrity by raising exceptions when input values cannot be successfully converted to the target type.
- Automatic Type Converters - Automatically transforms input data into target types to maintain type safety and data integrity.
- Data Type Conversions - Automates the conversion of values into target types or triggers errors when conversion fails in strict mode.
- Runtime - Transforms nested JSON and complex input formats into structured internal Ruby data types.
- User-Defined Types - Specifies expected data types for attributes to ensure consistent structures across all instantiated objects.
- Object-to-Data Mapping Frameworks - Maps raw JSON and nested structures into typed domain objects to decouple external data from internal logic.
- Data Modeling Libraries - Allows defining object schemas with typed attributes to ensure consistent data structures across the application.
- Value Objects - Implements immutable value objects that are compared by their internal attribute values rather than memory identity.
- Nested Data Transformers - Provides utilities for recursively transforming nested JSON and hash structures into hierarchical domain objects.
- Type Coercion Utilities - Automatically converts input data into specified target types during attribute assignment using internal transformation logic.
- Complex Type Coercion - Converts input data into structured formats like typed arrays, hashes, or nested objects.
- Writer Access Restrictions - Restricts the visibility of attribute setter methods to prevent external modification of an object's internal state.
- Writer Visibility Controls - Limits the visibility of attribute writers to prevent external modification of the internal object state.
- Strict Type Validation - Enforces data integrity by triggering exceptions when input values cannot be converted to the defined attribute type.
- Core Extensions - Adds attribute modeling to plain Ruby objects.
