lutaml-model 0.5.2 → 0.5.4

data/README.adoc

@@ -13,8 +13,9 @@ objects to and from various formats such as JSON, XML, YAML, and TOML. It uses
 an adapter pattern to support multiple libraries for each format, providing
 flexibility and extensibility for your data modeling needs.
 
-NOTE: Lutaml::Model is designed to be mostly compatible with the data modeling
-API of https://www.shalerb.org[Shale], an impressive Ruby data modeller.
+NOTE: The Lutaml::Model modeling Ruby API is designed to be mostly compatible
+with the data modeling API of https://www.shalerb.org[Shale], a data modeller
+for Ruby.
 Lutaml::Model is meant to address advanced needs not currently addressed by
 Shale.
 
@@ -48,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
                              │
@@ -95,54 +96,144 @@ Studio (Model)
 .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
+╔═══════════════════════╗                      ╔════════════════════════════╗
+║   LutaML Core Model   ║                      ║    Serialization Models    ║
+╚═══════════════════════╝                      ╚════════════════════════════╝
+
+╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮                      ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆          Model        ┆                      ┆          XML Model         ┆
+┆            │          ┆   ┌────────────────┐ ┆              │             ┆
+┆   ┌────────┴──┐       ┆   │                │ ┆       ┌──────┴──────┐      ┆
+┆   │           │       ┆   │     Model      │ ┆       │             │      ┆
+┆ Models   Value Types  ┆──►│ Transformation │ ┆    Models      Value Types ┆
+┆   │           │       ┆   │       &        │ ┆       │             │      ┆
+┆   │           │       ┆   │ Mapping Rules  │ ┆       │             │      ┆
+┆   │    ┌──────┴──┐    ┆   │                │ ┆  ┌────┴────┐      ┌─┴─┐    ┆
+┆   │    │         │    ┆   └────────────────┘ ┆  │         │      │   │    ┆
+┆   │   String  Integer ┆           │         ┆ Element  Value  xs:string  ┆
+┆   │   Date    Float   ┆           │          ┆ Attribute Type  xs:date    ┆
+┆   │   Time    Boolean ┆           ├──────►   ┆                 xs:boolean ┆
+┆   │                   ┆           │          ┆                 xs:anyURI  ┆
+┆   └──────┐            ┆           │          ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+┆          │            ┆           │
+┆     Contains          ┆           │          ╭┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╮
+┆     more Models       ┆           │          ┆          JSON Model        ┆
+┆     (recursive)       ┆           │          ┆              │             ┆
+┆                       ┆           │          ┆       ┌──────┴──────┐      ┆
+╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯           └───────►  ┆       │             │      ┆
+                                               ┆    Models      Value Types ┆
+                                               ┆       │             │      ┆
+                                               ┆       │             │      ┆
+                                               ┆  ┌────┴───┐     ┌───┴──┐   ┆
+                                               ┆  │        │     │      │   ┆
+                                               ┆ object array number string ┆
+                                               ┆ value        boolean null  ┆
+                                               ╰┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄╯
+----
+
+.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
+                         └─► }                      └─► }
 ----
 ====
 
@@ -278,6 +369,7 @@ attribute :name_of_attribute, {symbol | string | class}
 | `: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"}`
+| (nil value)           | `nil`                    | `xs:anyType`      | `null`    | `null`    | `null`
 // | `class`               | Custom class             | complex element   | object    | map       | `CustomObject`
 // | `collection: true`    | `Array` of type          | repeated elements | array     | sequence  | `[obj1, obj2]`
 // | `any`
@@ -921,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.
@@ -932,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.
 
@@ -944,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.
@@ -1667,6 +1764,7 @@ end
 
 // TODO: How to create mixed content from `#new`?
 
+
 [[xml-schema-location]]
 ==== Automatic support of `xsi:schemaLocation`
 
@@ -1926,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
 
@@ -3305,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
@@ -3696,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)