rasti-model 2.0.1 → 2.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cd4831ac82eadc7515e4103a10fe010346ec8719d16db0d30103a713b5cd15ef
-  data.tar.gz: b363b3bb323dbb5d1eec404e6adb7c3eef6d6673b0a19474d467a40551f280f8
+  metadata.gz: f31f21d81848581016911f75ce3b781e7603ef7bb39c3ea52ba860c7d12a8f01
+  data.tar.gz: e0ce2ae0c8303f5d2f87b4b0b3d4437f9ff8117eac6e9f6e44c71e3e5d16c190
 SHA512:
-  metadata.gz: 2e0659afca7e7f8a38731ea5901029f4f346895f357430970eba5f251745e2ceaa765ac9731e47c03a7504e2d66d9fccf57e08ea7f58230fabab8c86ca3e2962
-  data.tar.gz: aabf1480e4bd1b45c6cde754775714047beff31d89a571fb1b617f4aa4f174a65b922fecd8ddcd90ee3b2acaedf5e3aae70a63d33ddfdcbdde41bbe35fcb8fc9
+  metadata.gz: d6ffb39110babca82a4a714f2a08ad3fcc75028ebe083fd0b1386441a98a53e0d0d98d0e0b519eef91bc4e1f0da7e87b78dfae14cff8c41d6eae6db630ef6ac1
+  data.tar.gz: e5b31f2fbc7282d7ed3fb7757a4a8fb3e8b33f27e50c2c4d9c523bfa14b586fc5d65b53a8cc9f6befb568562295c704206c81426e1f5d882b04cc79cba25e9b1

data/README.md

@@ -3,7 +3,6 @@
 [![Gem Version](https://badge.fury.io/rb/rasti-model.svg)](https://rubygems.org/gems/rasti-model)
 [![CI](https://github.com/gabynaiman/rasti-model/actions/workflows/ci.yml/badge.svg)](https://github.com/gabynaiman/rasti-model/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/gabynaiman/rasti-model/badge.svg?branch=master)](https://coveralls.io/github/gabynaiman/rasti-model?branch=master)
-[![Code Climate](https://codeclimate.com/github/gabynaiman/rasti-model.svg)](https://codeclimate.com/github/gabynaiman/rasti-model)
 
 Domain models with typed attributes
 
@@ -35,6 +34,9 @@ end
 point = Point.new x: 1, y: 2
 point.x # => 1
 point.y # => 2
+
+# Unexpected attributes
+Point.new z: 3 # => Rasti::Model::UnexpectedAttributesError: Unexpected attributes: z
 ```
 
 ### Typed models
@@ -77,6 +79,54 @@ country.name # => 'Argentina'
 country.cities # => [City[name: "Buenos Aires"], City[name: "Córdoba"], City[name: "Rosario"]]
 
 country.to_h # => attributes
+
+# Attribute filtering
+country.to_h(only: [:name]) # => {name: "Argentina"}
+country.to_h(except: [:cities]) # => {name: "Argentina"}
+```
+
+### Default values
+```ruby
+class User < Rasti::Model
+  attribute :name, T::String
+  attribute :admin, T::Boolean, default: false
+  attribute :created_at, T::Time, default: ->(m) { Time.now }
+end
+
+user = User.new name: 'John'
+user.admin # => false
+user.created_at # => 2026-01-02 23:19:15 -0300
+```
+
+### Merging models
+```ruby
+point_1 = Point.new x: 1, y: 2
+point_2 = point_1.merge x: 10
+point_2.to_h # => {x: 10, y: 2}
+```
+
+### Custom attribute options
+You can add custom metadata to attributes that can be used later (e.g., for UI generation):
+
+```ruby
+class User < Rasti::Model
+  attribute :name, T::String, description: 'The user full name'
+end
+
+attribute = User.attributes.first
+attribute.option(:description) # => 'The user full name'
+```
+
+These options are also included in the schema representation.
+
+### Equality
+```ruby
+point_1 = Point.new x: 1, y: 2
+point_2 = Point.new x: 1, y: 2
+point_3 = Point.new x: 2, y: 1
+
+point_1 == point_2 # => true
+point_1 == point_3 # => false
 ```
 
 ### Error handling
@@ -86,8 +136,41 @@ TypedPoint = Rasti::Model[x: T::Integer, y: T::Integer]
 point = TypedPoint.new x: true
 point.x # => Rasti::Types::CastError: Invalid cast: true -> Rasti::Types::Integer
 point.y # => Rasti::Model::NotAssignedAttributeError: Not assigned attribute y
+
+# Bulk validation
+point = TypedPoint.new x: 'invalid', y: 'invalid'
+point.cast_attributes! # => Rasti::Types::CompoundError: x: ["Invalid cast: \"invalid\" -> Rasti::Types::Integer"], y: ["Invalid cast: \"invalid\" -> Rasti::Types::Integer"]
+```
+
+### Model Schema
+It is possible to obtain a serializable representation of the model structure (schema).
+
+```ruby
+Point = Rasti::Model[x: T::Integer, y: T::Integer]
+Point.to_schema
+# => {
+#      model: "Point",
+#      attributes: [
+#        {name: :x, type: :integer},
+#        {name: :y, type: :integer}
+#      ]
+#    }
+```
+
+#### Custom type serializers
+You can register custom serializers for your types to be used in the schema generation:
+
+```ruby
+Rasti::Model::Schema.register_type_serializer(MyCustomType, :custom)
+
+# Or with a block for more details
+Rasti::Model::Schema.register_type_serializer(MyCustomType) do |type|
+  {type: :custom, details: type.some_info}
+end
 ```
 
+Also, if a type responds to `to_schema`, it will be used.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/gabynaiman/rasti-model.

data/lib/rasti/model/schema.rb

@@ -0,0 +1,89 @@
+module Rasti
+  class Model
+    module Schema
+      class << self
+
+        def register_type_serializer(type, serialized_type=nil, &block)
+          type_serializers[type] = block || serialized_type
+        end
+
+        def serialize(model_class, visited=Set.new)
+          attributes = model_class.attributes.map do |attribute|
+            serialize_attribute(attribute, visited).merge(name: attribute.name)
+          end
+
+          {
+            model: model_class.name || model_class.to_s,
+            attributes: attributes
+          }
+        end
+
+        private
+
+        def type_serializers
+          @type_serializers ||= {}
+        end
+
+        def serialize_attribute(attribute, visited)
+          serialization = serialize_type(attribute.type, visited)
+          
+          options = attribute.send(:options)
+          serialization[:options] = options unless options.empty?
+          
+          serialization
+        end
+
+        def serialize_type(type, visited=Set.new)
+          if type.nil?
+            return {type: :any}
+          end
+
+          if (serializer = type_serializers[type])
+            return serializer.is_a?(Proc) ? serializer.call(type) : {type: serializer}
+          end
+
+          if type.respond_to? :to_schema
+            return type.to_schema
+          end
+
+          if type.is_a?(Class)
+            if type <= Types::String
+              {type: :string}
+            elsif type <= Types::Integer
+              {type: :integer}
+            elsif type <= Types::Float
+              {type: :float}
+            elsif type <= Types::Boolean
+              {type: :boolean}
+            elsif type <= Types::Symbol
+              {type: :symbol}
+            elsif type <= Types::Regexp
+              {type: :regexp}
+            else
+              {type: :unknown, details: type.name || type.to_s}
+            end
+          elsif type.is_a?(Types::Time)
+            {type: :time, format: type.format}
+          elsif type.respond_to?(:values)
+            {type: :enum, values: type.values}
+          elsif type.is_a?(Types::Array)
+            {type: :array, items: serialize_type(type.type, visited)}
+          elsif type.is_a?(Types::Hash)
+            {type: :hash, key_type: serialize_type(type.key_type, visited), value_type: serialize_type(type.value_type, visited)}
+          elsif type.is_a?(Types::Model)
+            model = type.model
+            model_name = model.name || model.to_s
+            if visited.include?(model)
+              {type: :model, model: model_name, schema: {model: model_name, attributes: []}}
+            else
+              {type: :model, model: model_name, schema: serialize(model, visited | Set[model])}
+            end
+          else
+            {type: :unknown, details: type.to_s}
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/model/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   class Model
-    VERSION = '2.0.1'
+    VERSION = '2.1.1'
   end
 end

data/lib/rasti/model.rb

@@ -1,5 +1,6 @@
 require 'multi_require'
 require 'rasti-types'
+require 'set'
 
 module Rasti
   class Model
@@ -32,6 +33,10 @@ module Rasti
         name || self.superclass.name
       end
 
+      def to_schema
+        Schema.serialize self
+      end
+
       def to_s
         "#{model_name}[#{attribute_names.join(', ')}]"
       end

data/spec/model_spec.rb

@@ -290,4 +290,139 @@ describe Rasti::Model do
     error.message.must_equal 'Attribute x already exists'
   end
 
+  describe 'Schema' do
+
+    it 'Simple' do
+      model = Rasti::Model[id: T::Integer, name: T::String]
+
+      model.to_schema.must_equal({
+        model: model.to_s,
+        attributes: [
+          {name: :id, type: :integer},
+          {name: :name, type: :string}
+        ]
+      })
+    end
+
+    it 'Complex' do
+      address_class = Rasti::Model[street: T::String, number: T::Integer]
+
+      model = Rasti::Model[
+        id: T::Integer, 
+        tags: T::Array[T::String], 
+        address: T::Model[address_class], 
+        metadata: T::Hash[T::Symbol, T::String],
+        status: T::Enum['active', 'inactive'],
+        created_at: T::Time['%Y-%m-%d']
+      ]
+
+      model.to_schema.must_equal({
+        model: model.to_s,
+        attributes: [
+          {name: :id, type: :integer},
+          {name: :tags, type: :array, items: {type: :string}},
+          {name: :address, type: :model, model: address_class.to_s, schema: {
+            model: address_class.to_s,
+            attributes: [
+              {name: :street, type: :string},
+              {name: :number, type: :integer}
+            ]
+          }},
+          {name: :metadata, type: :hash, key_type: {type: :symbol}, value_type: {type: :string}},
+          {name: :status, type: :enum, values: ['active', 'inactive']},
+          {name: :created_at, type: :time, format: '%Y-%m-%d'}
+        ]
+      })
+    end
+
+    it 'With options' do
+      model = Class.new(Rasti::Model) do
+        attribute :text, T::String, description: 'Basic text'
+      end
+
+      model.to_schema.must_equal({
+        model: model.to_s,
+        attributes: [
+          {name: :text, type: :string, options: {description: 'Basic text'}}
+        ]
+      })
+    end
+
+    it 'Type with to_schema' do
+      custom_type = Object.new
+      custom_type.define_singleton_method :to_schema do
+        {type: :custom, details: 'custom details'}
+      end
+
+      model = Rasti::Model[attr: custom_type]
+
+      model.to_schema.must_equal({
+        model: model.to_s,
+        attributes: [
+          {name: :attr, type: :custom, details: 'custom details'}
+        ]
+      })
+    end
+
+    it 'Self-referential model' do
+      node_class = Class.new(Rasti::Model) do
+        attribute :name, T::String
+      end
+      node_class.send(:attribute, :child, T::Model[node_class])
+
+      node_name = node_class.to_s
+
+      node_class.to_schema.must_equal({
+        model: node_name,
+        attributes: [
+          {type: :string, name: :name},
+          {type: :model, model: node_name, schema: {
+            model: node_name,
+            attributes: [
+              {type: :string, name: :name},
+              {type: :model, model: node_name, schema: {model: node_name, attributes: []}, name: :child}
+            ]
+          }, name: :child}
+        ]
+      })
+    end
+
+    it 'Mutually recursive models' do
+      person_class = Class.new(Rasti::Model) do
+        attribute :name, T::String
+      end
+
+      company_class = Class.new(Rasti::Model) do
+        attribute :name, T::String
+      end
+
+      person_class.send(:attribute, :employer, T::Model[company_class])
+      company_class.send(:attribute, :ceo, T::Model[person_class])
+
+      person_name = person_class.to_s
+      company_name = company_class.to_s
+
+      person_class.to_schema.must_equal({
+        model: person_name,
+        attributes: [
+          {type: :string, name: :name},
+          {type: :model, model: company_name, schema: {
+            model: company_name,
+            attributes: [
+              {type: :string, name: :name},
+              {type: :model, model: person_name, schema: {
+                model: person_name,
+                attributes: [
+                  {type: :string, name: :name},
+                  {type: :model, model: company_name, schema: {model: company_name, attributes: []}, name: :employer}
+                ]
+              }, name: :ceo}
+            ]
+          }, name: :employer}
+        ]
+      })
+    end
+
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rasti-model
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.1
 platform: ruby
 authors:
 - Gabriel Naiman
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-11 00:00:00.000000000 Z
+date: 2026-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_require
@@ -162,6 +162,7 @@ files:
 - lib/rasti/model.rb
 - lib/rasti/model/attribute.rb
 - lib/rasti/model/errors.rb
+- lib/rasti/model/schema.rb
 - lib/rasti/model/version.rb
 - rasti-model.gemspec
 - spec/coverage_helper.rb
@@ -171,7 +172,7 @@ homepage: https://github.com/gabynaiman/rasti-model
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -186,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.0.9
+signing_key:
 specification_version: 4
 summary: Domain models with typed attributes
 test_files: