lutaml-lml 0.1.8 → 0.2.0

data/lib/lutaml/lml/grammar/lml.parg

@@ -38,7 +38,7 @@ grammar Lml version "1.0.0" {
   boolean = ( "true" / "false" ) as boolean
   number = ( 1*%x30-39 "." 1*%x30-39 ) as float / ( 1*%x30-39 ) as number
   variable = quoted_string / 1*word
-  reference = "reference:(" ( variable *( "." variable ) ) as reference ")"
+  reference = ( "reference:(" / "ref:(" ) ( variable *( "." variable ) ) as reference ")"
   range = ( variable as start ".." variable as end ) as range
   namespaced_identifier = variable *( "::" variable )
   comment_definition = [ ws ] ( "**" / "#" ) ( *( !newline any_char ) ) as comments
@@ -49,8 +49,8 @@ grammar Lml version "1.0.0" {
   cardinality_body_definition = cardchar as min [ ".." [ cardchar as max ] ]
   cardinality = "[" cardinality_body_definition as cardinality "]"
 
-  value = boolean / reference / range / number / quoted_string
-  key_value_pair = variable as key ws [ "=" ] [ ws ] value as value
+  data_value = boolean / reference / range / number / quoted_string
+  key_value_pair = variable as key ws [ "=" ] [ ws ] data_value as value
   key_value_map = "{" [ whitespace ] ( *( key_value_pair whitespace ) ) as key_value_map "}"
   kw_visibility_modifier = "+" / "-" / "#" / "~"
 
@@ -69,8 +69,11 @@ grammar Lml version "1.0.0" {
 
   keyword_type_argument = "type" [ ws ] ( 1*nonspace ) as type [ whitespace ]
   keyword_cardinality_argument = "cardinality" [ ws ] cardinality_body_definition as cardinality [ whitespace ]
-  keyword_any_argument = [ ws ] ( 1*nonspace ) as name ws [ "=" ] [ ws ] attribute_value as value [ whitespace ]
-  keyword_attribute_options = *( keyword_type_argument / keyword_cardinality_argument / ( keyword_any_argument ) as properties )
+  keyword_any_argument = [ ws ] ( 1*nonspace ) as name ws [ "=" / ":" ] [ ws ] attribute_value as value [ whitespace ]
+  keyword_values_argument = "values" ws ( ( value_set_body ) as value_set / ( variable ) as value_set_ref ) [ whitespace ]
+  keyword_pattern_argument = ( "pattern" ws "/" ( *( ( "\\" any_char ) / ( !"/" any_char ) ) ) as pattern "/" [ whitespace ] )
+  value_set_body = "{" [ whitespace ] ( *( ( ( data_value / variable ) as item ) [ "," ] [ whitespace ] ) ) as items "}"
+  keyword_attribute_options = *( keyword_type_argument / keyword_cardinality_argument / keyword_values_argument / keyword_pattern_argument / ( keyword_any_argument ) as properties )
   keyword_attribute_body = "{" [ whitespace ] keyword_attribute_options [ whitespace ] "}"
   keyword_attribute_definition = ( "attribute" ws attribute_name [ ws ] keyword_attribute_body ) as attributes
 
@@ -89,18 +92,43 @@ grammar Lml version "1.0.0" {
 
   # ---- Definitions ----
   class_modifier = [ ( [ whitespace ] ( "abstract" / "interface" ) ) as modifier ws ]
+  # ---- Namespaces (RS 3010 extension: lutaml-model XmlNamespace) ----
+  namespace_uri_line = ( [ ws ] "uri" ws ( quoted_string / ( 1*word ) ) as uri [ whitespace ] )
+  namespace_prefix_line = ( [ ws ] "prefix" ws ( quoted_string / ( 1*word ) ) as prefix [ whitespace ] )
+  namespace_body = "{" [ whitespace ] ( *( namespace_uri_line / namespace_prefix_line ) ) as members "}"
+  namespace_inline = ( ws ( quoted_string ) as uri [ ws "prefix" ws ( quoted_string / ( 1*word ) ) as prefix ] )
+  namespace_definition = ( [ whitespace ] "namespace" ws ( 1*word ) as name [ ws ] ( namespace_body / namespace_inline ) [ whitespace ] ) as namespaces
+
+  # ---- Serialization mappings (RS 3010 extension: sibling-linked) ----
+  serialization_body = "{" [ whitespace ] ( *( serialization_line ) ) as rules "}"
+  serialization_line = ( mapping_element_name_line / mapping_element_line / mapping_attribute_line / mapping_content_line / mapping_namespace_line / mapping_mixed_line / legacy_map_line / mapping_map_line / mapping_map_key_line / mapping_map_value_line ) [ whitespace ]
+  legacy_map_line = ( [ ws ] "map" ws dq_string as wire "," ws "to:" ws ( quoted_string / ( 1*word ) ) as to [ whitespace ] ) as legacy_map
+  mapping_element_name_line = ( [ ws ] "element" ws dq_string as element_name [ whitespace ] ) as element_name
+  mapping_element_line = ( [ ws ] "map_element" ws ( element_args ) ) as map_element
+  element_args = ( dq_string as wire [ ws ( 1*word ) as field ] / ( 1*word ) as field )
+  mapping_attribute_line = ( [ ws ] "map_attribute" ws ( attribute_args ) ) as map_attribute
+  attribute_args = ( dq_string as wire [ ws ( 1*word ) as field ] / ( 1*word ) as field )
+  mapping_content_line = ( [ ws ] "map_content" ws ( 1*word ) as field ) as map_content
+  mapping_namespace_line = ( [ ws ] "namespace" ws ( 1*word ) as namespace_ref ) as map_namespace
+  mapping_mixed_line = ( [ ws ] "mixed_content" ) as mixed_content
+  mapping_map_line = ( [ ws ] "map" ws map_args ) as map
+  map_args = ( dq_string as wire ws ( 1*word ) as field / dq_string as wire / ( 1*word ) as field )
+  mapping_map_key_line = ( [ ws ] "map_key" ws "to_instance" ws ( 1*word ) as field ) as map_key
+  mapping_map_value_line = ( [ ws ] "map_value" ws ( "to_instance" / "as_attribute" ) as mode ws ( 1*word ) as field ) as map_value
+  mapping_definition = ( [ whitespace ] "mapping" ws ( 1*word ) as format ws ( 1*word ) as target [ ws ] serialization_body [ whitespace ] ) as serialization_mappings
+
   # ---- Mapping blocks (lutaml-model wire names) ----
   map_name = ( quoted_string / 1*( word / "-" / "." ) )
   map_line = [ ws ] "map" ws ( map_name ) as wire "," ws "to:" ws ( map_name ) as to [ whitespace ]
   mapping_body = [ ws ] "{" [ whitespace ] ( *( map_line ) ) as maps "}"
-  mapping_section = [ whitespace ] "mapping" ws ( variable ) as format mapping_body
+  class_mapping_section = ( [ whitespace ] "mapping" ws ( 1*word ) as format [ ws ] serialization_body [ whitespace ] ) as serialization_mappings
 
   derive_definition = ( [ whitespace ] "derive" ws attribute_name [ ws ] ":" [ ws ] [ quotes ] ( 1*typechar ) as type [ quotes ] ) as derived_field [ whitespace ]
   string_format_item = ( [ ws ] ( "artifact" / "root" ) as key ws ( quoted_string / 1*nonspace ) as value [ whitespace ] )
   string_format_body = "{" [ whitespace ] ( *( string_format_item ) ) as items [ whitespace ] "}"
   string_format_definition = ( [ whitespace ] "string_format" ws ( variable ) as format [ ws ] string_format_body ) as string_format
 
-  class_inner_definitions = definition_body / mapping_section / derive_definition / string_format_definition / ( !( "attribute" ws ) attribute_definition ) / keyword_attribute_definition / comment_definition / comment_multiline_definition
+  class_inner_definitions = definition_body / definition_line / class_mapping_section / derive_definition / string_format_definition / attribute_comma_definition / ( !( "attribute" ws ) attribute_definition ) / keyword_attribute_definition / comment_definition / comment_multiline_definition
   class_inner_definition = class_inner_definitions [ whitespace ]
   class_body = [ ws ] "{" [ whitespace ] ( *( class_inner_definition ) ) as members "}"
   parent_class = [ ws ] "<" [ ws ] ( class_name_chars ) as parent_class
@@ -109,12 +137,26 @@ grammar Lml version "1.0.0" {
   # Balanced-brace definition text: nested "{...}" and "\"-escapes allowed
   definition_content = *( ( "\\" any_char ) / ( "{" definition_content "}" ) / ( !"}" any_char ) )
   definition_body = [ ws ] "definition" [ whitespace ] "{" ( definition_content ) as definition "}"
+  definition_line = ( [ ws ] "definition" ws ( dq_string / sq_string ) ) as definition [ whitespace ]
 
   member_field_line = [ ws ] attribute_name [ ws ] ( 1*nonspace ) as member_field_type [ whitespace ]
   member_fields_definition = ( [ whitespace ] "member_fields" [ whitespace ] "{" [ whitespace ] ( *( member_field_line ) ) as member_fields [ whitespace ] "}" ) as member_fields_decl
+  attribute_comma_definition = ( [ whitespace ] "attribute" ws attribute_name "," [ ws ] ( 1*typechar ) as type [ ws ] [ "{" [ whitespace ] keyword_attribute_options [ whitespace ] "}" ] [ whitespace ] ) as attributes
   enum_member_with_payload = ( [ whitespace ] attribute_name [ ws ] ( class_body / keyword_attribute_body ) ) as attributes
 
-  enum_inner_definitions = definition_body / member_fields_definition / enum_member_with_payload / attribute_definition / comment_definition / comment_multiline_definition
+  # ---- Canonical value construct (RS 3001 par. Value / par. Enums) ----
+  # `value <name> { block }` is the canonical enum member; the bare
+  # identifier member is its documented shortcut. from_table expands to
+  # value members at compile time.
+  value_name = quoted_string / map_name
+  value_inner_definition = ( definition_body / definition_line / instance / attribute_line / comment_definition / comment_multiline_definition ) [ whitespace ]
+  value_body = "{" [ whitespace ] ( *( value_inner_definition ) ) as members "}"
+  value_definition = ( [ whitespace ] "value" ws ( value_name ) as value_name [ ws ] [ value_body ] [ whitespace ] ) as value_decl
+
+  from_table_definition = ( [ whitespace ] "from_table" [ ws ] ( map_name ) as from_table_name [ ws ] [ "{" [ whitespace ] *( "artifact" [ ws ] ( map_name ) as artifact_table [ whitespace ] ) "}" ] [ whitespace ] ) as from_table_decl
+
+  enum_values_shorthand = ( [ whitespace ] "values" ws value_set_body [ whitespace ] ) as value_set_decl
+  enum_inner_definitions = definition_body / definition_line / member_fields_definition / from_table_definition / enum_values_shorthand / value_definition / enum_member_with_payload / attribute_comma_definition / attribute_definition / comment_definition / comment_multiline_definition
   enum_inner_definition = enum_inner_definitions [ whitespace ]
   enum_body = [ ws ] "{" [ whitespace ] ( *( enum_inner_definition ) ) as members "}"
   enum_definition = [ whitespace ] "enum" ws [ quotes ] class_name as name [ quotes ] [ attribute_stereotype ] [ enum_body ]
@@ -122,12 +164,14 @@ grammar Lml version "1.0.0" {
   data_type_definition = [ whitespace ] "data_type" ws [ quotes ] class_name as name [ quotes ] [ attribute_stereotype ] [ data_type_body ]
   primitive_definition = [ whitespace ] "primitive" ws [ quotes ] class_name as name [ quotes ]
 
-  diagram_inner_definitions = title_definition / caption_definition / fontname_definition / ( class_definition ) as classes / ( enum_definition ) as enums / ( primitive_definition ) as primitives / ( data_type_definition ) as data_types / ( association_definition ) as associations / comment_definition / comment_multiline_definition
+  package_body = [ ws ] "{" [ whitespace ] ( *( diagram_inner_definition ) ) as members "}"
+  package_definition = ( [ whitespace ] "package" ws class_name as name [ ws ] package_body [ whitespace ] ) as packages
+  diagram_inner_definitions = namespace_definition / mapping_definition / package_definition / title_definition / caption_definition / fontname_definition / ( class_definition ) as classes / ( enum_definition ) as enums / ( primitive_definition ) as primitives / ( data_type_definition ) as data_types / ( association_definition ) as associations / comment_definition / comment_multiline_definition
   diagram_inner_definition = diagram_inner_definitions [ whitespace ]
   diagram_body = [ ws ] "{" [ whitespace ] ( *( diagram_inner_definition ) ) as members "}"
   diagram_definition = [ whitespace ] "diagram" [ ws ] class_name as name diagram_body [ whitespace ]
   diagram_definitions = diagram_definition [ whitespace ]
-  model_definitions = ( *( diagram_inner_definition ) ) as members
+  model_definitions = ( 1*( diagram_inner_definition ) ) as members
 
   view_only_definitions = ( view_import ) as view_imports / show_directive / hide_directive
   view_inner_definitions = view_only_definitions / diagram_inner_definitions
@@ -156,7 +200,8 @@ grammar Lml version "1.0.0" {
   require_block = ( *( require_stmt [ whitespace ] ) ) as requires
 
   # ---- Instances ----
-  instance = keyword_instance / class_instance
+  instance = instance_named / keyword_instance / class_instance
+  instance_named = ( [ whitespace ] "instance" ws quoted_string as name [ ws ] [ ( namespaced_identifier ) as instance_type ] [ ws ] "{" [ whitespace ] ( ( [ ws ] instance ) / attributes ) "}" [ whitespace ] ) as instance
   isa_definition = [ whitespace ] "isa" ws ( namespaced_identifier ) as isa [ whitespace ]
   keyword_instance = ( [ whitespace ] "instance" [ ws ( namespaced_identifier ) as instance_type ] [ ws ] "{" [ whitespace ] [ isa_definition ] ( ( [ ws ] instance ) / attributes ) "}" ) as instance [ whitespace ]
   class_instance = ( variable as instance_type [ whitespace ] quoted_string as name [ whitespace ] [ [ whitespace ] "extends" [ whitespace ] quoted_string as parent [ whitespace ] ] "{" [ whitespace ] [ lml_instance_body ] "}" ) as instance [ whitespace ]
@@ -164,11 +209,11 @@ grammar Lml version "1.0.0" {
   instance_template = [ whitespace ] "template" [ whitespace ] "{" [ whitespace ] attributes [ whitespace ] "}"
   lml_instance_members = ( instance_template ) as template / attributes
   models = [ whitespace ] "models" [ whitespace ] variable as name [ whitespace ] "{" ( *( ( ( string_format_definition ) as default_string_formats ) / model_body ) ) as members "}" [ whitespace ]
-  model_body = ( ( class_definition ) as classes / ( enum_definition ) as enums ) [ whitespace ]
+  model_body = diagram_inner_definition
 
   # ---- Data structures ----
-  attribute_value = instance / list / key_value_map / value / 1*( !%x0A any_char )
-  list_item = instance / value
+  attribute_value = instance / list / key_value_map / data_value / 1*( !%x0A any_char )
+  list_item = instance / data_value
   list = "[" [ whitespace ] ( *( list_item [ ws ] [ "," ] [ whitespace ] ) ) as list [ whitespace ] "]"
   collection = [ whitespace ] "collection" ws quoted_string as name [ ws ] "{" [ whitespace ] [ includes ] [ whitespace ] [ validation ] [ whitespace ] "}" [ whitespace ]
   includes = [ whitespace ] "includes" [ ws ] ( list ) as includes
@@ -176,14 +221,16 @@ grammar Lml version "1.0.0" {
   condition = [ whitespace ] "condition" ws quoted_string as condition [ whitespace ]
   import = [ whitespace ] "import" [ ws ] "{" [ whitespace ] ( *( import_definition ) ) as imports "}" [ whitespace ]
   import_definition = ( 1*nonspace ) as format_type [ ws ] quoted_string as file [ whitespace ] "{" [ whitespace ] attributes [ whitespace ] "}" [ whitespace ]
-  instances = [ whitespace ] "instances" [ whitespace ] "{" [ whitespace ] [ instances_body ] "}" [ whitespace ]
+  instances = [ whitespace ] "instances" [ ws ] [ ( quoted_string / variable ) as name ] [ whitespace ] "{" [ whitespace ] [ instances_body ] "}" [ whitespace ]
   instances_body = ( *( instances_member [ whitespace ] ) ) as instances
   instances_member = import / ( collection ) as collections / export / instance
   export = [ whitespace ] "export" [ whitespace ] "{" [ whitespace ] ( *( export_format [ whitespace ] ) ) as exports "}" [ whitespace ]
   export_format = [ whitespace ] "format" ws variable as format_type [ whitespace ] "{" [ whitespace ] attributes "}" [ whitespace ]
 
-  # ---- Root (grammar/instances.rb: Full) ----
-  diagram = [ require_block ] ( models / diagram_definitions / view_definitions / instances / instance / model_definitions )
+  # ---- Root (RS 3001: a document interleaves declarations) ----
+  diagram = [ require_block ] ( *( top_level_definition ) ) as members
+
+  top_level_definition = ( models / diagram_definitions / view_definitions / instances / instance / model_definitions ) [ whitespace ]
 }
 
 entry diagram: diagram

data/lib/lutaml/lml/model_compiler.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module Lutaml
   module Lml
     class ModelCompiler
@@ -7,9 +9,13 @@ module Lutaml
 
       TYPE_MAP = {
         'String' => :string,
+        'string' => :string,
         'Integer' => :integer,
+        'integer' => :integer,
         'Boolean' => :boolean,
+        'boolean' => :boolean,
         'Float' => :float,
+        'float' => :float,
         'Date' => :date,
         'date_time' => :date_time,
         'DateTime' => :date_time,
@@ -21,13 +27,17 @@ module Lutaml
       # declarations. Anything else must parse as an Integer.
       UNBOUNDED_TOKENS = %w[* n N unbounded].freeze
 
-      def initialize(namespace: nil, artifact_paths: {})
+      def initialize(namespace: nil, artifact_paths: {}, default_artifact: nil)
         @namespace = namespace
         @artifact_paths = artifact_paths
+        @default_artifact = default_artifact
         @compiled = {}
         @forward_refs = {}
         @enum_names = Set.new
         @enum_classes = {}
+        @declared_namespaces = []
+        @serialization_mappings = []
+        @namespace_classes = {}
       end
 
       def compile(input)
@@ -183,14 +193,30 @@ module Lutaml
       end
 
       def compile_document(doc)
+        @declared_namespaces = Array(doc.namespaces)
+        @serialization_mappings = Array(doc.serialization_mappings)
         doc.classes.each { |c| compile_class(c) }
+        hoist_class_serialization_mappings(doc)
         doc.enums.each { |e| compile_enum(e) }
         doc.data_types.each { |dt| compile_data_type(dt) }
         resolve_forward_references
         apply_xml_mappings
+        apply_key_value_mappings
         register_string_formats(doc)
       end
 
+      # In-class `mapping <format> { … }` is the shortcut for a sibling
+      # mapping targeting the enclosing class; hoist them so emission is
+      # uniform.
+      def hoist_class_serialization_mappings(doc)
+        (Array(doc.classes) + Array(doc.data_types)).each do |klass_def|
+          Array(klass_def.serialization_mappings).each do |mapping|
+            mapping.target = klass_def.name.to_s
+            @serialization_mappings << mapping
+          end
+        end
+      end
+
       def resolve_forward_references
         @forward_refs.each do |class_name, deferred_attrs|
           klass = @compiled[class_name]
@@ -232,6 +258,7 @@ module Lutaml
 
       def compile_enum(enum_def)
         name = enum_def.name.to_s
+        expand_from_table(enum_def)
         values = extract_enum_values(enum_def)
 
         payload_fields = Array(enum_def.member_fields).map(&:name).map(&:to_s)
@@ -246,7 +273,8 @@ module Lutaml
         end
 
         values.each do |value|
-          compiled_klass.define_singleton_method(value.name) do
+          accessor = value.name.to_s.gsub(/[^a-zA-Z0-9_]/, '_')
+          compiled_klass.define_singleton_method(accessor) do
             new({ value: value.name, description: value.description }.merge(value.payload || {}))
           end
         end
@@ -297,6 +325,9 @@ module Lutaml
         @compiled.each do |name, klass|
           next if @enum_names.include?(name)
 
+          custom = serialization_mapping_for(name, 'xml')
+          next apply_custom_xml_mapping(klass, custom) if custom
+
           apply_xml_mapping(klass, name)
         end
       end
@@ -313,16 +344,126 @@ module Lutaml
         end
       end
 
+      # RS 3010 extension: key-value mapping blocks for the declared
+      # formats (yaml/json/toml share lutaml-model's key_value model).
+      def apply_key_value_mappings
+        @compiled.each do |name, klass|
+          next if @enum_names.include?(name)
+
+          custom = serialization_mapping_for(name, 'key_value')
+          apply_custom_key_value_mapping(klass, custom) if custom
+        end
+      end
+
+      def serialization_mapping_for(target, format)
+        @serialization_mappings.find do |m|
+          m.target.to_s == target && serialization_format(m.format) == format
+        end
+      end
+
+      def serialization_format(format)
+        %w[yaml json toml].include?(format.to_s) ? 'key_value' : format.to_s
+      end
+
+      def apply_custom_xml_mapping(klass, mapping)
+        check_namespace_ambiguity(mapping)
+        ns_class = namespace_class_for(mapping.namespace_ref) if mapping.namespace_ref
+        rule_ns = mapping.rules.select { |r| r.kind == 'namespace' }
+                               .to_h { |r| [r.field, namespace_class_for(r.field)] }
+        klass.xml do |m|
+          m.root(mapping.element_name) if mapping.element_name
+          m.namespace(ns_class) if ns_class
+          m.mixed_content if mapping.mixed_content
+          mapping.rules.each do |rule|
+            case rule.kind
+            when 'element' then m.map_element(rule.wire, to: rule.field.to_sym)
+            when 'attribute' then m.map_attribute(rule.wire, to: rule.field.to_sym)
+            when 'content' then m.map_content(to: rule.field.to_sym)
+            when 'namespace' then m.namespace(rule_ns[rule.field])
+            end
+          end
+        end
+      end
+
+      def apply_custom_key_value_mapping(klass, mapping)
+        formats = mapping.format.to_s == 'key_value' ? %w[yaml json toml] : [mapping.format.to_s]
+        klass.instance_eval do
+          formats.each do |format|
+            public_send(format) do |m|
+              mapping.rules.each do |rule|
+                case rule.kind
+                when 'map' then m.map(rule.wire, to: rule.field.to_sym)
+                when 'key' then m.map_key(to_instance: rule.field.to_sym)
+                when 'value'
+                  if rule.mode == 'as_attribute'
+                    m.map_value(as_attribute: rule.field.to_sym)
+                  else
+                    m.map_value(to_instance: rule.field.to_sym)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def check_namespace_ambiguity(mapping)
+        return unless mapping.format.to_s == 'xml'
+        return if mapping.namespace_ref || @declared_namespaces.length < 2
+
+        raise ArgumentError,
+              "mapping #{mapping.format} #{mapping.target}: ambiguous default " \
+              "namespace — #{@declared_namespaces.length} namespaces in scope " \
+              "(#{@declared_namespaces.map(&:name).join(', ')}); declare one with " \
+              "'namespace <name>'"
+      end
+
+      def namespace_class_for(ref)
+        return nil if ref.nil?
+
+        require "lutaml/xml/namespace" unless defined?(Lutaml::Xml::Namespace)
+
+        ns_class = @namespace_classes[ref]
+        return ns_class if ns_class
+
+        declared = @declared_namespaces.find { |ns| ns.name.to_s == ref }
+        raise ArgumentError, "unknown namespace '#{ref}'" unless declared
+
+        ns_class = Class.new(Lutaml::Xml::Namespace)
+        uri = declared.uri
+        prefix = declared.prefix.to_s
+        ns_class.define_singleton_method(:uri) { uri }
+        ns_class.define_singleton_method(:prefix_default) { prefix }
+        @namespace_classes[ref] = ns_class
+      end
+
       def build_attributes(klass_def)
         Array(klass_def.attributes).map do |attr|
           attr_name = attr.name.to_sym
-          raw_type = attr.type.to_s
+          raw_type = resolve_values_type(klass_def, attr)
           type = resolve_type(raw_type)
           options = build_options(attr)
           [attr_name, raw_type, type, options]
         end
       end
 
+      # RS 3001 §Attribute: `values { v1, v2 }` expands into an anonymous
+      # enum baked from the inline set; the attribute is typed with it.
+      def resolve_values_type(klass_def, attr)
+        return attr.type.to_s unless attr.value_set&.any?
+
+        enum_name = anonymous_enum_name(klass_def.name, attr.name)
+        members = attr.value_set.map { |v| ::Lutaml::Lml::TopElementAttribute.new(name: v.to_s) }
+        compile_enum(::Lutaml::Lml::Enum.new(name: enum_name, attributes: members))
+        enum_name
+      end
+
+      def anonymous_enum_name(class_name, attr_name)
+        base = class_name.to_s.split('::').last
+        attr_part = attr_name.to_s.split('_').map(&:capitalize).join
+        "#{base}#{attr_part}Values"
+      end
+
       def resolve_type(type_name)
         if TYPE_MAP.key?(type_name)
           TYPE_MAP[type_name]
@@ -391,20 +532,76 @@ module Lutaml
         raise ValidationError, "Unrecognized cardinality token: #{val.inspect}"
       end
 
+      # L7a point 3: from_table members are baked at compile time — the
+      # artifact table's rows become the values, validated against the
+      # declared member_fields (unknown field = error; missing = nil).
+      # The member name comes from the row's "name" column.
+      def expand_from_table(enum_def)
+        return unless enum_def.from_table_name
+
+        rows = artifact_table_rows(enum_def)
+        known = Array(enum_def.member_fields).map { |f| f.name.to_s }
+        rows.each do |row|
+          row = row.transform_keys(&:to_s)
+          member_name = row.fetch('name')
+          unknown = row.keys - known - ['name']
+          if unknown.any?
+            raise ArgumentError,
+                  "enum #{enum_def.name}: table row #{member_name.inspect} has " \
+                  "undeclared fields #{unknown.inspect} (declared: #{known.inspect})"
+          end
+          payload = row.slice(*known).compact
+          enum_def.attributes << TopElementAttribute.new(
+            name: member_name,
+            properties: payload.map do |field, value|
+              TopElementAttribute.new(name: field, value: value)
+            end
+          )
+        end
+      end
+
+      def artifact_table_rows(enum_def)
+        reference = enum_def.from_table_artifact || @default_artifact
+        path = artifact_path_for(reference.to_s)
+        unless path
+          raise ArgumentError,
+                "enum #{enum_def.name}: from_table artifact #{reference.inspect} not found"
+        end
+
+        envelope = JSON.parse(File.read(path))
+        table = envelope['tables'].to_h[enum_def.from_table_name]
+        unless table
+          raise ArgumentError,
+                "enum #{enum_def.name}: table #{enum_def.from_table_name.inspect} " \
+                "not found in artifact #{reference.inspect}"
+        end
+
+        table['rows'].to_a
+      end
+
       def extract_enum_values(enum_def)
         member_fields = Array(enum_def.member_fields).map do |f|
           [f.name.to_s, f.type.to_s]
         end
         enum_def.attributes.map do |attr|
-          description = Array(attr.attributes).find do |nested|
-            nested.name == 'description'
-          end
+          description = member_description(attr)
           payload = extract_member_payload(attr)
           validate_member_payload(enum_def, attr, payload, member_fields)
-          EnumValue.new(attr.name.to_s, description&.type, payload)
+          EnumValue.new(attr.name.to_s, description, payload)
         end
       end
 
+      # The member description rides a nested attribute named `description`
+      # (bare-member form) or `definition` (RS 3001 `value` blocks); both
+      # spellings are accepted.
+      def member_description(attr)
+        nested = Array(attr.attributes).find do |n|
+          %w[description definition].include?(n.name.to_s)
+        end
+        text = nested&.type || nested&.definition || nested&.value
+        text.is_a?(Hash) && text.key?(:string) ? text[:string] : text
+      end
+
       # L7a: per-member payload lines ride the keyword-attribute
       # properties (`abbreviation = "WD"`)
       def extract_member_payload(attr)
@@ -457,18 +654,12 @@ module Lutaml
       def register_string_formats(doc)
         defaults = doc.packages.flat_map(&:default_string_formats)
         doc.classes.each do |class_def|
-          Array(class_def.string_formats).each do |fmt|
-            register_string_format(class_def.name.to_s, fmt)
-          end
-          next if Array(class_def.string_formats).any? do |f|
-            f.format == defaults.first&.format
-          end
-
-          defaults.each do |fmt|
-            next if Array(class_def.string_formats).map(&:format).include?(fmt.format)
+          declared = Array(class_def.string_formats)
+          declared.each { |fmt| register_string_format(class_def.name.to_s, fmt) }
 
-            register_string_format(class_def.name.to_s, fmt)
-          end
+          declared_formats = declared.map(&:format)
+          defaults.reject { |fmt| declared_formats.include?(fmt.format) }
+                  .each { |fmt| register_string_format(class_def.name.to_s, fmt) }
         end
       end
 

data/lib/lutaml/lml/models/data_type.rb

@@ -7,6 +7,7 @@ module Lutaml
       attribute :name, :string
       attribute :wire_mappings, "Lutaml::Lml::Mapping", collection: true, default: -> { [] }
       attribute :derived_fields, "Lutaml::Lml::DerivedField", collection: true, default: -> { [] }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
       attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string, default: "dataType"
       attribute :stereotype, :string, collection: true, default: -> { [] }

data/lib/lutaml/lml/models/document.rb

@@ -16,6 +16,8 @@ module Lutaml
       attribute :data_types, "Lutaml::Lml::DataType", collection: true, default: -> { [] }
       attribute :enums, "Lutaml::Lml::Enum", collection: true, default: -> { [] }
       attribute :packages, "Lutaml::Lml::Package", collection: true, default: -> { [] }
+      attribute :namespaces, "Lutaml::Lml::Namespace", collection: true, default: -> { [] }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
       attribute :primitives, "Lutaml::Lml::PrimitiveType", collection: true, default: -> { [] }
       attribute :associations, "Lutaml::Lml::Association", collection: true, default: -> { [] }
       attribute :diagrams, "Lutaml::Lml::Diagram", collection: true, default: -> { [] }

data/lib/lutaml/lml/models/enum.rb

@@ -18,6 +18,8 @@ module Lutaml
                                                                    default: -> { [] }
       attribute :modifier, :string
       attribute :member_fields, "Lutaml::Lml::MemberField", collection: true, default: -> { [] }
+      attribute :from_table_name, :string
+      attribute :from_table_artifact, :string
       attribute :operations, "Lutaml::Lml::Operation", collection: true, default: -> { [] }
       attribute :values, "Lutaml::Lml::Value", collection: true, default: -> { [] }
 

data/lib/lutaml/lml/models/instance.rb

@@ -3,6 +3,7 @@
 module Lutaml
   module Lml
     class Instance < Lutaml::Model::Serializable
+      attribute :name, :string
       attribute :type, :string
       attribute :isa, :string
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true

data/lib/lutaml/lml/models/instance_collection.rb

@@ -3,6 +3,7 @@
 module Lutaml
   module Lml
     class InstanceCollection < Lutaml::Model::Serializable
+      attribute :name, :string
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
       attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []
       attribute :exports, "Lutaml::Lml::InstancesExport", collection: true, default: []

data/lib/lutaml/lml/models/mapping_rule.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # One line of a serialization mapping: what kind of mapping (element,
+    # attribute, content, map, key, value), the serialization-side wire
+    # name, the model attribute it binds, and the qualifier mode for
+    # key/value collections (to_instance, as_attribute).
+    class MappingRule < Lutaml::Model::Serializable
+      attribute :kind, :string
+      attribute :wire, :string
+      attribute :field, :string
+      attribute :mode, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/namespace.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3010 extension: a declared XML namespace (uri + optional prefix).
+    # The compiler generates the corresponding Lutaml::Model::XmlNamespace
+    # subclass for the compiled model namespace.
+    class Namespace < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :uri, :string
+      attribute :prefix, :string
+    end
+  end
+end

data/lib/lutaml/lml/models/serialization_mapping.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3010 extension: a serialization mapping declared separately from
+    # its class and linked by target name —
+    #   mapping xml Ceramic { element "ceramic" … }
+    class SerializationMapping < Lutaml::Model::Serializable
+      attribute :format, :string
+      attribute :target, :string
+      attribute :element_name, :string
+      attribute :namespace_ref, :string
+      attribute :mixed_content, :boolean, default: false
+      attribute :rules, 'Lutaml::Lml::MappingRule', collection: true, default: -> { [] }
+    end
+  end
+end

data/lib/lutaml/lml/models/top_element_attribute.rb

@@ -19,6 +19,8 @@ module Lutaml
       attribute :definition, Lutaml::Lml::Types::TextType
       attribute :association, :string
       attribute :default, :string
+      attribute :value_set, :string, collection: true, default: -> { [] }
+      attribute :pattern, :string
 
       # LML-specific attributes
       attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
@@ -53,6 +55,8 @@ module Lutaml
         map "definition", to: :definition
         map "association", to: :association
         map "default", to: :default
+        map "value_set", to: :value_set
+        map "pattern", to: :pattern
         map "properties", to: :properties
         map "value", to: :value, with: { to: :value_to, from: :value_from }
         map "attributes", to: :attributes

data/lib/lutaml/lml/models/uml_class.rb

@@ -26,6 +26,7 @@ module Lutaml
       attribute :wire_mappings, "Lutaml::Lml::Mapping", collection: true, default: -> { [] }
       attribute :string_formats, "Lutaml::Lml::StringFormat", collection: true, default: -> { [] }
       attribute :derived_fields, "Lutaml::Lml::DerivedField", collection: true, default: -> { [] }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
 
       # LML-specific
       attribute :parent_class, :string