lutaml-model 0.3.23 → 0.3.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7e401ce23a01b4dc80f709b71326b598cb9b9024b81d2a94f501bebf8112a14
-  data.tar.gz: 30534172ee835a9170e4335029702ec87ec4225c52e9e09566cb694fbd9c258d
+  metadata.gz: 923c122ff4459f02c1949dc88ee8df94b93db6ce23c00c9da2159f6b376da3a0
+  data.tar.gz: aa537363d67a5383cdbd280cfa9ddee0a3c5de0cb151b79b2e195a030bc0061d
 SHA512:
-  metadata.gz: ce9d2be7aac031cba94181053fa59f19cb61ed6fafbdda177bec369a03fd92d53dcfc9caf43a34ebb439c7d69d2bf3f0db1a56a49e5cc34021a8fe4a0fc7fe25
-  data.tar.gz: 187168f579188ad1458013375fd5bacb6718dbb29d77994229c1c11fb14bcec5df8bae8bcfbe42dc3e57a5918c663741df7168338a2df36869562613aa06d149
+  metadata.gz: a0da4f4a87c8fe4a3951d302df5797594675f83616ea52b4582f417683d4f55076c57ad3d6f3018119c0a6021497bf6832b150ebf695d1fa8d4304da2040b641
+  data.tar.gz: 0d4d6d783728b53d453c23e2cfcfcd08d9eac83d94b4652d3bdee95c19d9d9bf68e233dea6d29d9478d4214271dd800be93b8f8e11a59cf9f9cd46d744dd2002

data/.rubocop_todo.yml

@@ -1,19 +1,19 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2024-11-03 22:29:56 UTC using RuboCop version 1.66.1.
+# on 2024-11-11 10:52:30 UTC using RuboCop version 1.68.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 124
+# Offense count: 132
 # This cop supports safe autocorrection (--autocorrect).
 # Configuration parameters: Max, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, AllowedPatterns.
 # URISchemes: http, https
 Layout/LineLength:
   Enabled: false
 
-# Offense count: 11
+# Offense count: 12
 # Configuration parameters: AllowedMethods.
 # AllowedMethods: enums
 Lint/ConstantDefinitionInBlock:
@@ -22,15 +22,17 @@ Lint/ConstantDefinitionInBlock:
     - 'spec/lutaml/model/schema/relaxng_schema_spec.rb'
     - 'spec/lutaml/model/schema/xsd_schema_spec.rb'
     - 'spec/lutaml/model/schema/yaml_schema_spec.rb'
+    - 'spec/lutaml/model/type_spec.rb'
     - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
-# Offense count: 1
+# Offense count: 2
 Lint/DuplicateMethods:
   Exclude:
     - 'lib/lutaml/model/attribute.rb'
+    - 'lib/lutaml/model/type/float.rb'
 
-# Offense count: 37
+# Offense count: 36
 # Configuration parameters: AllowedMethods, AllowedPatterns, CountRepeatedAttributes, Max.
 Metrics/AbcSize:
   Exclude:
@@ -40,7 +42,6 @@ Metrics/AbcSize:
     - 'lib/lutaml/model/schema/relaxng_schema.rb'
     - 'lib/lutaml/model/schema/xsd_schema.rb'
     - 'lib/lutaml/model/serialize.rb'
-    - 'lib/lutaml/model/type.rb'
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
@@ -52,19 +53,19 @@ Metrics/AbcSize:
 Metrics/BlockLength:
   Max: 47
 
-# Offense count: 27
+# Offense count: 26
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/CyclomaticComplexity:
   Exclude:
     - 'lib/lutaml/model/attribute.rb'
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/serialize.rb'
-    - 'lib/lutaml/model/type.rb'
+    - 'lib/lutaml/model/type/integer.rb'
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
 
-# Offense count: 51
+# Offense count: 53
 # Configuration parameters: CountComments, CountAsOne, AllowedMethods, AllowedPatterns.
 Metrics/MethodLength:
   Max: 46
@@ -74,13 +75,14 @@ Metrics/MethodLength:
 Metrics/ParameterLists:
   Max: 13
 
-# Offense count: 22
+# Offense count: 23
 # Configuration parameters: AllowedMethods, AllowedPatterns, Max.
 Metrics/PerceivedComplexity:
   Exclude:
     - 'lib/lutaml/model/attribute.rb'
     - 'lib/lutaml/model/comparable_model.rb'
     - 'lib/lutaml/model/serialize.rb'
+    - 'lib/lutaml/model/type/integer.rb'
     - 'lib/lutaml/model/xml_adapter/nokogiri_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/ox_adapter.rb'
     - 'lib/lutaml/model/xml_adapter/xml_document.rb'
@@ -95,7 +97,7 @@ RSpec/ContextWording:
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_mapping_spec.rb'
 
-# Offense count: 110
+# Offense count: 117
 # Configuration parameters: CountAsOne.
 RSpec/ExampleLength:
   Max: 54
@@ -106,13 +108,14 @@ RSpec/IndexedLet:
   Exclude:
     - 'spec/address_spec.rb'
 
-# Offense count: 19
+# Offense count: 20
 RSpec/LeakyConstantDeclaration:
   Exclude:
     - 'spec/lutaml/model/schema/json_schema_spec.rb'
     - 'spec/lutaml/model/schema/relaxng_schema_spec.rb'
     - 'spec/lutaml/model/schema/xsd_schema_spec.rb'
     - 'spec/lutaml/model/schema/yaml_schema_spec.rb'
+    - 'spec/lutaml/model/type_spec.rb'
     - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
 
@@ -124,7 +127,7 @@ RSpec/MultipleDescribes:
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_adapter_spec.rb'
 
-# Offense count: 125
+# Offense count: 149
 RSpec/MultipleExpectations:
   Max: 14
 
@@ -133,24 +136,34 @@ RSpec/MultipleExpectations:
 RSpec/MultipleMemoizedHelpers:
   Max: 9
 
-# Offense count: 4
+# Offense count: 9
 # Configuration parameters: AllowedGroups.
 RSpec/NestedGroups:
   Max: 4
 
-# Offense count: 7
+# Offense count: 13
 RSpec/PendingWithoutReason:
   Exclude:
     - 'spec/lutaml/model/mixed_content_spec.rb'
+    - 'spec/lutaml/model/type/date_time_spec.rb'
+    - 'spec/lutaml/model/type/integer_spec.rb'
+    - 'spec/lutaml/model/type/time_spec.rb'
+    - 'spec/lutaml/model/type/time_without_date_spec.rb'
     - 'spec/lutaml/model/validation_spec.rb'
     - 'spec/lutaml/model/xml_adapter/oga_adapter_spec.rb'
     - 'spec/lutaml/model/xml_adapter/xml_namespace_spec.rb'
     - 'spec/lutaml/model/xml_adapter_spec.rb'
 
-# Offense count: 1
+# Offense count: 2
 RSpec/RemoveConst:
   Exclude:
     - 'spec/lutaml/model/type/decimal_spec.rb'
+    - 'spec/lutaml/model/type_spec.rb'
+
+# Offense count: 2
+RSpec/RepeatedExampleGroupBody:
+  Exclude:
+    - 'spec/lutaml/model/type/time_without_date_spec.rb'
 
 # Offense count: 2
 RSpec/RepeatedExampleGroupDescription:
@@ -167,6 +180,12 @@ RSpec/SpecFilePathFormat:
     - 'spec/lutaml/model/defaults_spec.rb'
     - 'spec/lutaml/model/type/decimal_spec.rb'
 
+# Offense count: 1
+# Configuration parameters: IgnoreNameless, IgnoreSymbolicNames.
+RSpec/VerifiedDoubles:
+  Exclude:
+    - 'spec/lutaml/model/type/hash_spec.rb'
+
 # Offense count: 1
 Security/CompoundHash:
   Exclude:

data/README.adoc

@@ -22,6 +22,17 @@ NOTE: Instructions on how to migrate from Shale to Lutaml::Model are provided in
 <<migrate-from-shale>>.
 
 
+== Features
+
+* Define models with attributes and types
+* Serialize and deserialize models to/from JSON, XML, YAML, and TOML
+* Support for multiple serialization libraries (e.g., `toml-rb`, `tomlib`)
+* Configurable adapters for different serialization formats
+* Support for collections and default values
+* Custom serialization/deserialization methods
+* XML namespaces and mappings
+
+
 == Data modeling in a nutshell
 
 Data modeling is the process of creating a data model for the data to be stored
@@ -32,16 +43,110 @@ Lutaml::Model simplifies data modeling in Ruby by allowing you to define models
 with attributes and serialize/deserialize them to/from various serialization
 formats seamlessly.
 
+The Lutaml::Model data modelling approach is as follows:
+
+.Modeling relationships of a LutaML Model
+[source]
+----
+                       Lutaml Model
+                             │
+                    Has many attributes
+                             │
+                             ▼
+                        Attribute
+                             │
+                        Has type of
+                             │
+                  ┌──────────┴──────────┐
+                  │                     │
+                Model              Value (Leaf)
+                  │                     │
+       Has many attributes    Contains one basic value
+                  │                     │
+          ┌───────┴─────┐        ┌──────┴──────┐
+          │             │        │             │
+        Model      Value (Leaf)  String       Integer
+          │                      Date         Boolean
+          │                      Time         Float
+  Has many attributes            ...          ...
+          │
+          ▼
+  (Recursive pattern continues...)
+----
+
+.Example of LutaML Model instance with assigned values
+====
+[source]
+----
+Studio (Model)
+ ├── name (Value: String) = "Pottery Studio"
+ ├── address (Model)
+ │    ├── street (Value: String) = "123 Clay St"
+ │    ├── city (Value: String) = "Ceramics City"
+ │    └── postcode (Value: String) = "12345"
+ ├── established (Value: Date) = 2020-01-01
+ └── kilns (Model)
+      ├── count (Value: Integer) = 3
+      └── temperature (Value: Float) = 1200.0
+----
+====
+
+
+.Modeling relationships of a LutaML Model to serialization models
+[source]
+----
+    Core Model                  Serialization Model
+    ==========                  ===================
+        │                           (mapping)
+        │                               │
+        ▼                               ▼
+      Model                         XML Model
+        │                               │
+  ┌─────┴─────┐                  ┌──────┴──────┐
+  │           │                  │             │
+Models   Value Types ────┬──►  Models     Value Types
+  │           │          │       │             │
+  │           │          │       │             │
+  │    ┌──────┴──┐       │  ┌────┴────┐      ┌─┴─┐
+  │    │         │       │  │         │      │   │
+  │   String  Integer    │ Element  Value  xs:string
+  │   Date    Float      │ Attribute Type  xs:date
+  │   Time    Boolean    │                 xs:boolean
+  │                      │                 xs:anyURI
+  └──────┐               │
+         │               │         JSON Model
+    Contains             │              │
+    more Models          │       ┌──────┴──────┐
+    (recursive)          │       │             │
+                         └──►  Models     Value Types
+                                 │             │
+                                 │             │
+                            ┌────┴────┐      ┌─┴─┐
+                            │         │      │   │
+                           object  array  number string
+                           value          boolean null
+----
+
+.Example of LutaML Model instance transformed into a serialization model and serialized to JSON
+====
+[source]
+----
+Studio (Core Model)          JSON Model                Serialized JSON
+    │                            │                            │
+    ▼                            ▼                            ▼
+name: "Studio 1"     ┌─► { "name": "...",         {
+address:             │     "address": {             "name": "Studio 1",
+  ├── street: "..."  │       "street": "...",       "address": {
+  └── city: "..."    │       "city": "..."    ──►     "street": "...",
+kilns:               │     },                         "city": "..."
+  ├── count: 3       │    "kilnsCount": ...,        },
+  └── temp: 1200     │    "kilnsTemp": ...          "kilnsCount": 3,
+                     └─► }                          "kilnsTemp": 1200
+                                                  }
+----
+====
 
-== Features
 
-* Define models with attributes and types
-* Serialize and deserialize models to/from JSON, XML, YAML, and TOML
-* Support for multiple serialization libraries (e.g., `toml-rb`, `tomlib`)
-* Configurable adapters for different serialization formats
-* Support for collections and default values
-* Custom serialization/deserialization methods
-* XML namespaces and mappings
 
 == Installation
 
@@ -150,6 +255,8 @@ same class and all their attributes are equal.
 Lutaml::Model supports the following attribute types, they can be
 referred by a string, a symbol, or their class constant.
 
+Every type has a corresponding Ruby class and a serialization format type.
+
 Syntax:
 
 [source,ruby]
@@ -159,20 +266,20 @@ attribute :name_of_attribute, {symbol | string | class}
 
 .Mapping between Lutaml::Model::Type classes, Ruby equivalents and serialization format types
 |===
-| Lutaml::Model::Type   | Ruby Class               | XML               | JSON               | YAML        | Example Value
-
-| `:string`             | `String`                 | `xs:string`       | `string`           | `string`    | `"text"`
-| `:integer`            | `Integer`                | `xs:integer`      | `number`           | `integer`   | `42`
-| `:float`              | `Float`                  | `xs:decimal`      | `number`           | `float`     | `3.14`
-| `:boolean`            | `TrueClass`/`FalseClass` | `xs:boolean`      | `boolean`          | `boolean`   | `true/false`
-| `:date`               | `Date`                   | `xs:date`         | `string` (ISO8601) | `date`      | `"2024-01-01"`
-| `:time_without_date`  | `Time`                   | `xs:time`         | `string` (ISO8601) | `time`      | `"12:34:56"`
-| `:date_time`          | `DateTime`               | `xs:dateTime`     | `string` (ISO8601) | `timestamp` | `"2024-01-01T00:00:00Z"`
-| `:time`               | `Time`                   | `xs:dateTime`     | `string` (ISO8601) | `timestamp` | `"2024-01-01T00:00:00Z"`
-| `:decimal` (optional) | `BigDecimal`             | `xs:decimal`      | `number`           | `float`     | `123.45`
-| `:hash`               | `Hash`                   | complex element   | `object`           | `map`       | `{key: "value"}`
-| `class`               | Custom Class             | complex element   | `object`           | `map`       | `CustomObject`
-| `collection: true`    | `Array` of Type          | repeated elements | `array`            | `sequence`  | `[obj1, obj2]`
+| Lutaml::Model::Type   | Ruby class               | XML               | JSON      | YAML        | Example value
+
+| `:string`             | `String`                 | `xs:string`       | `string`  | `string`  | `"text"`
+| `:integer`            | `Integer`                | `xs:integer`      | `number`  | `integer` | `42`
+| `:float`              | `Float`                  | `xs:decimal`      | `number`  | `float`   | `3.14`
+| `:boolean`            | `TrueClass`/`FalseClass` | `xs:boolean`      | `boolean` | `boolean` | `true`, `false`
+| `:date`               | `Date`                   | `xs:date`         | `string`  | `string`  | `2024-01-01` (JSON/YAML `"2024-01-01"`)
+| `:time_without_date`  | `Time`                   | `xs:time`         | `string`  | `string`  | `"12:34:56"`
+| `:date_time`          | `DateTime`               | `xs:dateTime`     | `string`  | `string`  | `"2024-01-01T12:00:00+00:00"`
+| `:time`               | `Time`                   | `xs:dateTime`     | `string`  | `string`  | `"2024-01-01T12:00:00+00:00"`
+| `:decimal` (optional) | `BigDecimal`             | `xs:decimal`      | `number`  | `float`   | `123.45`
+| `:hash`               | `Hash`                   | complex element   | object    | map       | `{key: "value"}`
+// | `class`               | Custom class             | complex element   | object    | map       | `CustomObject`
+// | `collection: true`    | `Array` of type          | repeated elements | array     | sequence  | `[obj1, obj2]`
 // | `any`
 
 |===
@@ -204,14 +311,17 @@ end
 ----
 ====
 
-==== (optional) Decimal type
+==== Decimal type
 
-The `BigDecimal` class is no longer part of the standard Ruby library from Ruby
-3.4 onwards, hence the `Decimal` type is only enabled when the `bigdecimal`
-library is loaded.
+The Decimal type is an optional type that is disabled by default.
 
-This means that the following code needs to be run before using (and parsing)
-the `Decimal` type:
+NOTE: The reason why the Decimal type is disalbed by default is that the
+`BigDecimal` class became optional to the standard Ruby library from Ruby 3.4
+onwards. The `Decimal` type is only enabled when the `bigdecimal` library is
+loaded.
+
+The following code needs to be run before using (and parsing) the Decimal
+type:
 
 [source,ruby]
 ----
@@ -222,6 +332,142 @@ If the `bigdecimal` library is not loaded, usage of the `Decimal` type will
 raise a `Lutaml::Model::TypeNotSupportedError`.
 
 
+==== Custom type
+
+A custom class can be used as an attribute type. The custom class must inherit
+from `Lutaml::Model::Type::Value` or a class that inherits from it.
+
+A class inheriting from the `Value` class carries the attribute `value` which
+stores the one-and-only "true" value that is independent of serialization
+formats.
+
+The minimum requirement for a custom class is to implement the following
+methods:
+
+`self.cast(value)`:: Assignment of an external value to the `Value` class to be
+set as `value`. Casts the value to the custom type.
+
+`self.serialize(value)`:: Serializes the custom type to an object (e.g. a
+string). Takes the internal `value` and converts it into an output suitable for
+serialization.
+
+
+.Using a custom value type to normalize a postcode with minimal methods
+[example]
+====
+[source,ruby]
+----
+class FiveDigitPostCode < Lutaml::Model::Type::String
+  def self.cast(value)
+    value = value.to_s if value.is_a?(Integer)
+
+    unless value.is_a?(::String)
+      raise Lutaml::Model::InvalidValueError, "Invalid value for type 'FiveDigitPostCode'"
+    end
+
+    # Pad zeros to the left
+    value.rjust(5, '0')
+  end
+
+  def self.serialize(value)
+    value
+  end
+end
+
+class Studio < Lutaml::Model::Serializable
+  attribute :postcode, FiveDigitPostCode
+end
+----
+====
+
+
+==== Serialization of custom types
+
+The serialization of custom types can be made to differ per serialization format
+by defining methods in the class definitions. This requires additional methods
+than the minimum required for a custom class (i.e. `self.cast(value)` and
+`self.serialize(value)`).
+
+This is useful in the case when different serialization formats of the same
+model expect differentiated value representations.
+
+The methods that can be overridden are named:
+
+`self.from_{format}(serialized_string)`:: Deserializes a string of the
+serialization format and returns the object to be assigned to the `Value` class'
+`value`.
+
+`to_{format}`:: Serializes the object to a string of the serialization format.
+
+The `{format}` part of the method name is the serialization format in lowercase
+(e.g. `json`, `xml`, `yaml`, `toml`).
+
+.Using custom serialization methods to handle a high-precision date-time type
+[example]
+====
+Suppose in XML we handle a high-precision date-time type that requires custom
+serialization methods, but other formats such as JSON do not support this type.
+
+For instance, in the normal DateTime class, the serialized string is
+`2012-04-07T01:51:37+02:00`, and the high-precision format is
+`2012-04-07T01:51:37.112+02:00`.
+
+We create `HighPrecisionDateTime` class is a custom class that inherits
+from `Lutaml::Model::Type::DateTime`.
+
+[source,ruby]
+----
+class HighPrecisionDateTime < Lutaml::Model::Type::DateTime
+  # Inherit the `self.cast(value)` and `self.serialize(value)` methods
+  # from Lutaml::Model::Type::DateTime
+
+  # The format looks like this `2012-04-07T01:51:37.112+02:00`
+  def self.from_xml(xml_string)
+    ::DateTime.parse(xml_string)
+  end
+
+  # The %L adds milliseconds to the time
+  def to_xml
+    value.strftime('%Y-%m-%dT%H:%M:%S.%L%:z')
+  end
+end
+
+class Ceramic < Lutaml::Model::Serializable
+  attribute :kiln_firing_time, HighPrecisionDateTime
+  xml do
+    root 'ceramic'
+    map_element 'kilnFiringTime', to: :kiln_firing_time
+    # ...
+  end
+end
+----
+
+An XML snippet with the high-precision date-time type:
+
+[source,xml]
+----
+<ceramic>
+  <kilnFiringTime>2012-04-07T01:51:37.112+02:00</kilnFiringTime>
+  <!-- ... -->
+</ceramic>
+----
+
+When loading the XML snippet, the `HighPrecisionDateTime` class will be used to
+parse the high-precision date-time string.
+
+However, when serializing to JSON, the value will have the high-precision
+part lost due to the inability of JSON to handle high-precision date-time.
+
+[source,ruby]
+----
+> c = Ceramic.from_xml(xml)
+> #<Ceramic:0x0000000104ac7240 @kiln_firing_time=#<HighPrecisionDateTime:0x0000000104ac7240 @value=2012-04-07 01:51:37.112000000 +0200>>
+> c.to_json
+> # {"kilnFiringTime":"2012-04-07T01:51:37+02:00"}
+----
+====
+
+
 === Attribute as a collection
 
 Define attributes as collections (arrays or hashes) to store multiple values

data/lib/lutaml/model/attribute.rb

@@ -34,15 +34,23 @@ module Lutaml
 
       def cast_type!(type)
         case type
+        when Symbol
+          begin
+            Type.lookup(type)
+          rescue UnknownTypeError
+            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+          end
+        when String
+          begin
+            Type.const_get(type)
+          rescue NameError
+            raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
+          end
         when Class
           type
-        when String
-          Type.const_get(type)
-        when Symbol
-          Type.const_get(type.to_s.split("_").collect(&:capitalize).join)
+        else
+          raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
         end
-      rescue NameError
-        raise ArgumentError, "Unknown Lutaml::Model::Type: #{type}"
       end
 
       def cast_value(value)
@@ -194,7 +202,9 @@ module Lutaml
         elsif type <= Serialize
           type.hash_representation(value, format, options)
         else
-          type.serialize(value)
+          # Convert to Value instance if not already
+          value = type.new(value) unless value.is_a?(Type::Value)
+          value.send(:"to_#{format}")
         end
       end
 
@@ -208,7 +218,7 @@ module Lutaml
         elsif type <= Serialize && value.is_a?(Hash)
           type.apply_mappings(value, format, options)
         else
-          Lutaml::Model::Type.cast(value, type)
+          type.cast(value)
         end
       end
 

data/lib/lutaml/model/error/type_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class TypeError < Error
+      def initialize(message)
+        super("Type Error: #{message}")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/unknown_type_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class UnknownTypeError < Error
+      def initialize(type_name)
+        super("Unknown type '#{type_name}'")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/validation_error.rb

@@ -1,4 +1,3 @@
-# lib/lutaml/model/error/validation_error.rb
 module Lutaml
   module Model
     class ValidationError < Error

data/lib/lutaml/model/error.rb

@@ -11,3 +11,5 @@ require_relative "error/unknown_adapter_type_error"
 require_relative "error/collection_count_out_of_range_error"
 require_relative "error/validation_error"
 require_relative "error/type_not_enabled_error"
+require_relative "error/type_error"
+require_relative "error/unknown_type_error"

data/lib/lutaml/model/serialize.rb

@@ -35,7 +35,7 @@ module Lutaml
           subclass.instance_variable_set(:@attributes,
                                          Utils.deep_dup(@attributes))
           subclass.instance_variable_set(:@mappings, Utils.deep_dup(@mappings))
-          subclass.instance_variable_set(:@model, @model || subclass)
+          subclass.instance_variable_set(:@model, subclass)
         end
 
         def model(klass = nil)
@@ -310,7 +310,10 @@ module Lutaml
         def apply_xml_mapping(doc, instance, options = {})
           return instance unless doc
 
-          options[:default_namespace] = mappings_for(:xml)&.namespace_uri if options[:default_namespace].nil?
+          if options[:default_namespace].nil?
+            options[:default_namespace] =
+              mappings_for(:xml)&.namespace_uri
+          end
           mappings = mappings_for(:xml).mappings
 
           if doc.is_a?(Array)
@@ -398,6 +401,8 @@ module Lutaml
                     value.map do |v|
                       text_hash?(attr, v) ? v["text"] : v
                     end
+                  elsif attr&.raw? && value
+                    value.node.children.map(&:to_xml).join
                   elsif text_hash?(attr, value)
                     value["text"]
                   else