lutaml-model 0.5.3 → 0.5.4

data/README.adoc

@@ -49,12 +49,12 @@ The Lutaml::Model data modelling approach is as follows:
 .Modeling relationships of a LutaML Model
 [source]
 ----
-                       Lutaml Model
+                       LutaML Model
                              │
                     Has many attributes
                              │
                              ▼
-                        Attribute
+                         Attribute
                              │
                         Has type of
                              │
@@ -97,7 +97,7 @@ Studio (Model)
 [source]
 ----
 ╔═══════════════════════╗                      ╔════════════════════════════╗
-║       Core Model      ║                      ║    Serialization Models    ║
+║   LutaML Core Model   ║                      ║    Serialization Models    ║
 ╚═══════════════════════╝                      ╚════════════════════════════╝
 
 ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮                      ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
@@ -109,8 +109,8 @@ Studio (Model)
 ┆   │           │       ┆   │       &        │ ┆       │             │      ┆
 ┆   │           │       ┆   │ Mapping Rules  │ ┆       │             │      ┆
 ┆   │    ┌──────┴──┐    ┆   │                │ ┆  ┌────┴────┐      ┌─┴─┐    ┆
-┆   │    │         │    ┆   │                │ ┆  │         │      │   │    ┆
-┆   │   String  Integer ┆   └────────────────┘ ┆ Element  Value  xs:string  ┆
+┆   │    │         │    ┆   └────────────────┘ ┆  │         │      │   │    ┆
+┆   │   String  Integer ┆           │         ┆ Element  Value  xs:string  ┆
 ┆   │   Date    Float   ┆           │          ┆ Attribute Type  xs:date    ┆
 ┆   │   Time    Boolean ┆           ├──────►   ┆                 xs:boolean ┆
 ┆   │                   ┆           │          ┆                 xs:anyURI  ┆
@@ -131,22 +131,109 @@ Studio (Model)
                                                ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
 ----
 
+.Model transformation of a LutaML Model to another LutaML Model
+[source]
+----
+╔═══════════════════════╗   ╔══════════════════╗   ╔═══════════════════════╗
+║LutaML Model Class FOO ║   ║LutaML Transformer║   ║LutaML Model Class BAR ║
+╚═══════════════════════╝   ╚══════════════════╝   ╚═══════════════════════╝
+
+╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮                          ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆          Model        ┆                          ┆          Model        ┆
+┆            │          ┆    ┌────────────────┐    ┆            │          ┆
+┆   ┌────────┴──┐       ┆    │                │    ┆   ┌────────┴──┐       ┆
+┆   │           │       ┆    │     Model      │    ┆   │           │       ┆
+┆ Models   Value Types  ┆───►│ Transformation │───►┆ Models   Value Types  ┆
+┆   │           │       ┆◄───│       &        │◄───┆   │           │       ┆
+┆   │           │       ┆    │ Mapping Rules  │    ┆   │           │       ┆
+┆   │    ┌──────┴──┐    ┆    │                │    ┆   │    ┌──────┴──┐    ┆
+┆   │    │         │    ┆    └────────────────┘    ┆   │    │         │    ┆
+┆   │   String  Integer ┆                          ┆   │   String  Integer ┆
+┆   │   Date    Float   ┆                          ┆   │   Date    Float   ┆
+┆   │   Time    Boolean ┆                          ┆   │   Time    Boolean ┆
+┆   │                   ┆                          ┆   │                   ┆
+┆   └──────┐            ┆                          ┆   └──────┐            ┆
+┆          │            ┆                          ┆          │            ┆
+┆     Contains          ┆                          ┆     Contains          ┆
+┆     more Models       ┆                          ┆     more Models       ┆
+┆     (recursive)       ┆                          ┆     (recursive)       ┆
+┆                       ┆                          ┆                       ┆
+╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯                          ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+----
+
+.The `Value` class, transformation, and serialization formats
+[source]
+----
+╔═══════════════════════╗                          ╔═══════════════════════╗
+║LutaML Value Class FOO ║                          ║  Serialization Value  ║
+╚═══════════════════════╝                          ╚═══════════════════════╝
+╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮                          ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆   ┌───────────────┐   ┆                          ┆   ┌───────────────┐   ┆
+┆   │     Value     │   ┆   ┌──────────────────┐   ┆   │   XML Value   │   ┆
+┆   └───────────────┘   ┆──►│ Value Serializer │──►┆   └───────────────┘   ┆
+┆   ┌───────────────┐   ┆   └──────────────────┘   ┆   ┌───────────────┐   ┆
+┆   │Primitive Types│   ┆                          ┆   │XML Value Types│   ┆
+┆   └───────────────┘   ┆                          ┆   └───────────────┘   ┆
+┆ ┌───┘                 ┆                          ┆ ┌───┘                 ┆
+┆ ├─ string             ┆                          ┆ ├─ xs:string          ┆
+┆ ├─ integer            ┆                          ┆ ├─ xs:integer         ┆
+┆ ├─ float              ┆                          ┆ ├─ xs:decimal         ┆
+┆ ├─ boolean            ┆                          ┆ ├─ xs:boolean         ┆
+┆ ├─ date               ┆                          ┆ ├─ xs:date            ┆
+┆ ├─ time_without_date  ┆                          ┆ ├─ xs:time            ┆
+┆ ├─ date_time          ┆                          ┆ ├─ xs:dateTime        ┆
+┆ ├─ time               ┆                          ┆ ├─ xs:decimal         ┆
+┆ ├─ decimal            ┆                          ┆ ├─ xs:anyType         ┆
+┆ └─ hash               ┆                          ┆ └─ (complex element)  ┆
+╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯                          ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+           │
+           ▼
+  ┌───────────────────┐
+  │ Value Transformer │
+  └───────────────────┘
+           │
+           ▼
+╔═══════════════════════╗
+║LutaML Value Class BAR ║
+╚═══════════════════════╝
+╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆   ┌───────────────┐   ┆
+┆   │     Value     │   ┆
+┆   └───────────────┘   ┆
+┆   ┌───────────────┐   ┆
+┆   │Primitive Types│   ┆
+┆   └───────────────┘   ┆
+┆ ┌───┘                 ┆
+┆ ├─ string             ┆
+┆ ├─ integer            ┆
+┆ ├─ float              ┆
+┆ ├─ boolean            ┆
+┆ ├─ date               ┆
+┆ ├─ time_without_date  ┆
+┆ ├─ date_time          ┆
+┆ ├─ time               ┆
+┆ ├─ decimal            ┆
+┆ └─ hash               ┆
+╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+----
+
 .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
-                                                  }
+╔═════════════════════╗     ╔═════════════════════╗     ╔═════════════════════╗
+║ Studio (Core Model) ║     ║     JSON Model      ║     ║   Serialized JSON   ║
+╚═════════════════════╝     ╚═════════════════════╝     ╚═════════════════════╝
+
+  name: "Studio 1"       ┌─► {                      ┌─► {
+  address:               │     "name": "...",       │     "name": "Studio 1",
+    ├── street: "..."    │     "address": {         │     "address": {
+    └── city: "..."      │       "street": "...",   │       "street": "...",
+  kilns:               ──┤       "city": "..."    ──┤       "city": "..."
+    ├── count: 3         │     },                   │     },
+    └── temp: 1200       │    "kilnsCount": ...,    │     "kilnsCount": 3,
+                         │    "kilnsTemp": ...      │     "kilnsTemp": 1200
+                         └─► }                      └─► }
 ----
 ====
 
@@ -926,10 +1013,8 @@ end
 ----
 ====
 
-
-==== Mapping all content (XML only)
-
-WARNING: This feature is only applicable to XML (for now).
+[[xml-map-all]]
+==== Mapping all XML content
 
 The `map_all` tag in XML mapping captures and maps all content within an XML
 element into a single attribute in the target Ruby object.
@@ -937,6 +1022,12 @@ element into a single attribute in the target Ruby object.
 The use case for `map_all` is to tell Lutaml::Model to not parse the content of
 the XML element at all, and instead handle it as an XML string.
 
+NOTE: The corresponding method for key-value formats is at <<key-value-map-all>>.
+
+WARNING: Notice that usage of mapping all will lead to incompatibility between
+serialization formats, i.e. the raw string content will not be portable as
+objects are across different formats.
+
 This is useful in the case where the content of an XML element is not to be
 handled by a Lutaml::Model::Serializable object.
 
@@ -949,8 +1040,9 @@ This includes:
 * attributes
 * text nodes
 
-The `map_all` tag is **exclusive** and cannot be combined with other mappings (`map_element`, `map_content`) except for `map_attribute` for the same element, ensuring
-it captures the entire inner XML content.
+The `map_all` tag is **exclusive** and cannot be combined with other mappings
+(`map_element`, `map_content`) except for `map_attribute` for the same element,
+ensuring it captures the entire inner XML content.
 
 NOTE: An error is raised if `map_all` is defined alongside any other mapping in
 the same XML mapping context.
@@ -1672,6 +1764,7 @@ end
 
 // TODO: How to create mixed content from `#new`?
 
+
 [[xml-schema-location]]
 ==== Automatic support of `xsi:schemaLocation`
 
@@ -1931,6 +2024,102 @@ end
 ----
 ====
 
+[[key-value-map-all]]
+==== Mapping all key-value content
+
+The `map_all` tag captures and maps all content within a serialization format
+into a single attribute in the target Ruby object.
+
+The use case for `map_all` is to tell Lutaml::Model to not parse the content at
+all, and instead handle it as a raw string.
+
+NOTE: The corresponding method for XML is at <<xml-map-all>>.
+
+WARNING: Notice that usage of mapping all will lead to incompatibility between
+serialization formats, i.e. the raw string content will not be portable as
+objects are across different formats.
+
+This is useful when the content needs to be handled as-is without parsing into
+individual attributes.
+
+The `map_all` tag is **exclusive** and cannot be combined with other mappings,
+ensuring it captures the entire content.
+
+NOTE: An error is raised if `map_all` is defined alongside any other mapping in
+the same mapping context.
+
+Syntax:
+
+[source,ruby]
+----
+json | yaml | toml | key_value do
+  map_all to: :name_of_attribute
+end
+----
+
+.Using `map_all` to capture all content across different formats
+[example]
+====
+[source,ruby]
+----
+class Document < Lutaml::Model::Serializable
+  attribute :content, :string
+
+  json do
+    map_all to: :content
+  end
+
+  yaml do
+    map_all to: :content
+  end
+
+  toml do
+    map_all to: :content
+  end
+end
+----
+
+For JSON:
+[source,json]
+----
+{
+  "sections": [
+    { "title": "Introduction", "text": "Chapter 1" },
+    { "title": "Conclusion", "text": "Final chapter" }
+  ],
+  "metadata": {
+    "author": "John Doe",
+    "date": "2024-01-15"
+  }
+}
+----
+
+For YAML:
+[source,yaml]
+----
+sections:
+  - title: Introduction
+    text: Chapter 1
+  - title: Conclusion
+    text: Final chapter
+metadata:
+  author: John Doe
+  date: 2024-01-15
+----
+
+The content is preserved exactly as provided:
+
+[source,ruby]
+----
+> doc = Document.from_json(json_content)
+> puts doc.content
+> # "{\"sections\":[{\"title\":\"Introduction\",\"text\":\"Chapter 1\"},{\"title\":\"Conclusion\",\"text\":\"Final chapter\"}],\"metadata\":{\"author\":\"John Doe\",\"date\":\"2024-01-15\"}}"
+
+> doc = Document.from_yaml(yaml_content)
+> puts doc.content
+> # "sections:\n  - title: Introduction\n    text: Chapter 1\n  - title: Conclusion\n    text: Final chapter\nmetadata:\n  author: John Doe\n  date: 2024-01-15\n"
+----
+====
 
 ==== Nested attribute mappings
 
@@ -3310,6 +3499,181 @@ end
 ====
 
 
+== Importing data models
+
+=== General
+
+Lutaml::Model provides a way to import data models defined from various formats
+into the LutaML data modeling system.
+
+Data model languages supported are:
+
+* XSD (https://w3.org/TR/xmlschema-1/[XML Schema Definition Language])
+// * RNC (https://relaxng.org/compact-tutorial-20030326.html[RELAX NG Compact Syntax])
+// * RNG (https://relaxng.org/relaxng-compact.html[RELAX NG XML Syntax])
+// * JSON Schema (https://json-schema.org/understanding-json-schema/[JSON Schema])
+// * YAML Schema (https://yaml.org/spec/1.2/spec.html[YAML])
+// * LutaML
+
+
+The following figure illustrates the process of importing an XML Schema model to
+create LutaML core models. Once the LutaML core models are created, they can be
+used to parse and generate XML documents according to the imported XML Schema
+model.
+
+Today, the LutaML core models are written into Ruby files, which can be used to
+parse and generate XML documents according to the imported XML Schema.
+This is to be changed so that the LutaML core models are directly loaded and
+interpreted.
+
+.Importing an XML Schema model to create LutaML core models
+[source]
+----
+╔════════════════════════════╗                        ╔═══════════════════════╗
+║    Serialization Models    ║                        ║       Core Model      ║
+╚════════════════════════════╝                        ╚═══════════════════════╝
+
+╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮                        ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆  XML Schema (XSD/RNG/RNC)  ┆                        ┆          Model        ┆
+┆              │             ┆   ┌────────────────┐   ┆            │          ┆
+┆       ┌──────┴──────┐      ┆   │                │   ┆   ┌────────┴──┐       ┆
+┆       │             │      ┆   │     Model      │   ┆   │           │       ┆
+┆    Models      Value Types ┆──►│   Importing    │──►┆ Models   Value Types  ┆
+┆       │             │      ┆   │                │   ┆   │           │       ┆
+┆       │             │      ┆   └────────────────┘   ┆   │           │       ┆
+┆  ┌────┴────┐      ┌─┴─┐    ┆           │            ┆   │    ┌──────┴──┐    ┆
+┆  │         │      │   │    ┆           │            ┆   │    │         │    ┆
+┆ Element  Value  xs:string  ┆           │            ┆   │   String  Integer ┆
+┆ Attribute Type  xs:date    ┆           │            ┆   │   Date    Float   ┆
+┆ Union  Complex  xs:boolean ┆           │            ┆   │   Time    Boolean ┆
+┆ Sequence Choice xs:anyURI  ┆           │            ┆   │                   ┆
+╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯           │            ┆   └──────┐            ┆
+                                         │            ┆          │            ┆
+                                         │            ┆     Contains          ┆
+                                         │            ┆     more Models       ┆
+                                         │            ┆     (recursive)       ┆
+                                         │            ┆                       ┆
+                                         │            ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+                                         │            ┌────────────────┐
+                                         │            │                │
+                                         │            │     Model      │
+                                         └──────────► │ Transformation │
+                                                      │       &        │
+                                                      │ Mapping Rules  │
+                                                      │                │
+                                                      └────────────────┘
+----
+
+
+[[xml-schema-to-model-files]]
+=== XML Schema (XSD)
+
+W3C XSD is a schema language designed to define the structure of XML documents,
+alongside other XML schema languages like DTD, RELAX NG, and Schematron.
+
+Lutaml::Model supports the import of XSD schema files to define information
+models that can be used to parse and generate XML documents.
+
+Specifically, the `Lutaml::Model::Schema#from_xml` method loads XML Schema files
+(XSD, `*.xsd`) and generates Ruby files (`*.rb`) that inherit from
+`Lutaml::Model::Serializable` that are saved to disk.
+
+Syntax:
+
+[source,ruby]
+----
+Lutaml::Model::Schema.from_xml(
+  xsd_schema, <1>
+  options: options <2>
+)
+----
+<1> The `xsd_schema` is the XML Schema string to be converted to model files.
+<2> The `options` hash is an optional argument.
+
+`options`:: Optional hash containing potentially the following key-values.
+
+`output_dir`::: The directory where the model files will be saved. If not
+provided, a default directory named `lutaml_models_<timestamp>` is created.
++
+[example]
+`"path/to/directory"`
+
+`namespace`::: The namespace of the schema. This will be added in the
+`Lutaml::Model::Serializable` file's `xml do` block.
++
+[example]
+`http://example.com/namespace`
+
+`prefix`::: The prefix of the namespace provided in the `namespace` option.
++
+[example]
+`example-prefix`
+
+`location`::: The URL or path of the directory containing all the files of the
+schema. For more information, refer to the
+link:https://www.w3.org/TR/xmlschema-1/#include[XML Schema specification].
++
+[example]
+`"http://example.com/example.xsd"`
++
+[example]
+`"path/to/schema/directory"`
+
+
+The generated LutaML models consists of two different kind of Ruby classes
+depending on the XSD schema:
+
+XSD "SimpleTypes":: converted into classes that inherit from
+`Lutaml::Model::Type::Value`, which define the data types with restrictions and
+other validations of these values.
+
+XSD "ComplexTypes":: converted into classes that inherit from
+`Lutaml::Model::Serializable` that model according to the defined structure.
+
+Lutaml::Model uses the https://github.com/lutaml/lutaml-xsd[`lutaml-xsd` gem] to
+automatically resolve the `include` and `import` elements, enabling
+*Lutaml-Model* to generate the corresponding model files.
+
+This auto-resolving feature allows seamless integration of these files into your
+models without the need for manual resolution of includes and imports.
+
+[example]
+.Using `Lutaml::Model::Schema#from_xml` to convert an XML Schema to model files
+====
+[source,ruby]
+----
+xsd_schema = <<~XSD
+  <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+    /* your schema here */
+  </xs:schema>
+XSD
+options = {
+  # These are all optional:
+  output_dir: 'path/to/directory',
+  namespace: 'http://example.com/namespace',
+  prefix: "example-prefix",
+  location: "http://example.com/example.xsd"
+  # or
+  # location: "path/to/schema/directory"
+}
+
+# generates the files in the output_dir | default_dir
+Lutaml::Model::Schema.from_xml(xsd_schema, options: options)
+----
+====
+
+You could also directly load the generated Ruby files into your application by
+requiring them.
+
+[example]
+.Using the generated Ruby files in your application
+====
+[source,ruby]
+----
+Lutaml::Model::Schema.from_xml(xsd_schema, options: {output_dir: 'path/to/directory'})
+require_relative 'path/to/directory/*.rb'
+----
+====
 
 
 == Validation
@@ -3701,6 +4065,15 @@ attribute for every element.
 | Requires manual specification on every XML element that uses it.
 |
 
+
+| Compiling XML Schema to *Lutaml::Model::Serializable* classes
+| Yes. Using <<xml-schema-to-model-files, `Lutaml::Model::Schema#from_xml`>>
+
+1. *ComplexTypes* are compiled to *Lutaml::Model::Serializable* classes containing the attributes.
+2. *SimpleTypes* are compiled to *Lutaml::Model::Type::Value* classes to support XML Schema level validations.
+| Yes, Provides only an array of the classes and doesn't support `simple types` with restrictions and/or other validations.
+|
+
 4+h| Attribute features
 
 | Attribute delegation

data/lib/lutaml/model/constants.rb

@@ -0,0 +1,7 @@
+module Lutaml
+  module Model
+    module Constants
+      RAW_MAPPING_KEY = "__raw_mapping".freeze
+    end
+  end
+end

data/lib/lutaml/model/error/type/invalid_value_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class InvalidValueError < Error
+        def initialize(message)
+          @message = message
+
+          super()
+        end
+
+        def to_s
+          @message
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -16,3 +16,4 @@ require_relative "error/type_error"
 require_relative "error/unknown_type_error"
 require_relative "error/multiple_mappings_error"
 require_relative "error/collection_true_missing_error"
+require_relative "error/type/invalid_value_error"

data/lib/lutaml/model/key_value_mapping.rb

@@ -36,6 +36,27 @@ module Lutaml
 
       alias map_element map
 
+      def map_all(
+        to: nil,
+        render_nil: false,
+        render_default: false,
+        with: {},
+        delegate: nil
+      )
+        @raw_mapping = true
+        validate!(Constants::RAW_MAPPING_KEY, to, with)
+        @mappings << KeyValueMappingRule.new(
+          Constants::RAW_MAPPING_KEY,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+          with: with,
+          delegate: delegate,
+        )
+      end
+
+      alias map_all_content map_all
+
       def name_for_mapping(root_mappings, name)
         return "root_mapping" if root_mappings
 
@@ -43,12 +64,14 @@ module Lutaml
       end
 
       def validate!(key, to, with)
-        if to.nil? && with.empty?
+        validate_mappings!(key)
+
+        if to.nil? && with.empty? && !@raw_mapping
           msg = ":to or :with argument is required for mapping '#{key}'"
           raise IncorrectMappingArgumentsError.new(msg)
         end
 
-        if !with.empty? && (with[:from].nil? || with[:to].nil?)
+        if !with.empty? && (with[:from].nil? || with[:to].nil?) && !@raw_mapping
           msg = ":with argument for mapping '#{key}' requires :to and :from keys"
           raise IncorrectMappingArgumentsError.new(msg)
         end
@@ -62,6 +85,12 @@ module Lutaml
         end
       end
 
+      def validate_mappings!(_type)
+        if (@raw_mapping && Utils.present?(@mappings)) || (!@raw_mapping && @mappings.any?(&:raw_mapping?))
+          raise StandardError, "map_all is not allowed with other mappings"
+        end
+      end
+
       def deep_dup
         self.class.new.tap do |new_mapping|
           new_mapping.instance_variable_set(:@mappings, duplicate_mappings)

data/lib/lutaml/model/mapping_hash.rb

@@ -36,6 +36,14 @@ module Lutaml
         key?("#cdata-section") || key?("text")
       end
 
+      def assign_or_append_value(key, value)
+        self[key] = if self[key]
+                      [self[key], value].flatten
+                    else
+                      value
+                    end
+      end
+
       def ordered?
         @ordered
       end

data/lib/lutaml/model/mapping_rule.rb

@@ -84,6 +84,10 @@ module Lutaml
         name.is_a?(Array)
       end
 
+      def raw_mapping?
+        name == Constants::RAW_MAPPING_KEY
+      end
+
       def deep_dup
         raise NotImplementedError, "Subclasses must implement `deep_dup`."
       end