lutaml-lml 0.3.4 → 0.3.5

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

@@ -9,7 +9,28 @@
 # capture binds the whole match (Parslet's `.repeat.as(:x)` shape);
 # `[ x as k ]` yields k: nil when absent (Parslet omits the key —
 # consumers treat nil and absent as equivalent).
-grammar Lml version "1.0.0" {
+grammar Lml version "1.0.0" edition 2 {
+  # ---- Glue (parsanol-ruby#364) ----
+  # Edition 2 names every uncaptured rule reference; these are the
+  # token mechanics the tree must not see: separators that eat `;` and
+  # comments, verbatim-scan classes, quote delimiters, identifier
+  # runs and keyword tokens. Declaring the whole chain keeps the tree
+  # the authored captures only — byte-identical to edition 1 (the
+  # corpus differential proves it). Un-glue a rule when its node
+  # should surface.
+  glue whitespace line_comment block_comment
+  glue any_char quotes
+  glue word nonspace class_run class_name_chars type_run type_token quoted_name_run
+  glue definition_content
+  glue kw_abstract_sp kw_artifact_sp kw_association_sp kw_attribute_sp kw_caption_sp
+  glue kw_class_sp kw_collection_sp kw_condition_sp kw_data_type_sp kw_definition_sp
+  glue kw_derive_sp kw_element_sp kw_enum_sp kw_fontname_sp kw_format_sp kw_hide_sp
+  glue kw_import_sp kw_instance_sp kw_isa_sp kw_lml_sp kw_map_attribute_sp kw_map_content_sp
+  glue kw_map_element_sp kw_map_key_sp kw_map_sp kw_map_value_sp kw_mapping_sp kw_member_sp
+  glue kw_member_type_sp kw_namespace_sp kw_owner_sp kw_owner_type_sp kw_package_sp
+  glue kw_pattern_sp kw_prefix_sp kw_primitive_sp kw_require_sp kw_show_sp
+  glue kw_string_format_sp kw_title_sp kw_to_instance_sp kw_uri_sp kw_value_sp
+  glue kw_values_sp kw_version_sp kw_visibility_sp
   # ---- Trivia (parsanol-ruby#134 skip rule) ----
   # Grammar-native trivia replaces the pre-parse comment stripping:
   # `//` line and `/* */` block comments (RS 3001 par. Comment) plus
@@ -136,14 +157,17 @@ grammar Lml version "1.0.0" {
   visibility = kw_visibility_modifier as visibility_modifier
   attribute_stereotype = "<<" ( 1*( %x41-5A / %x61-7A / %x30-39 / "_" / "-" / "/" ) ) as stereotype ">>"
   atomic type_run = 1*( !( "//" / "/*" ) ( %x41-5A / %x61-7A / %x30-39 / "_" / "-" / ":" / "/" / "+" ) )
-  atomic type_token = type_run *( %x20 type_run )
+  atomic type_token = type_run *( %x20 !( "as" 1*" " ":" ) type_run )
   atomic namechar = %x41-5A / %x61-7A / %x30-39 / "_" / "-" / "/" / "+"
   attribute_type = [ ":" ] [ attribute_stereotype ] [ quotes as type_literal ] ( type_token ) as type [ quotes ]
   attribute_name = ( 1*namechar ) as name
   atomic quoted_name_run = 1*( %x41-5A / %x61-7A / %x30-39 / "_" / "-" / "/" / "+" )
   atomic quoted_name_body = quoted_name_run *( %x20 quoted_name_run )
   attribute_definition_name = ( quotes ( quoted_name_body ) as name quotes ) / attribute_name
-  attribute_definition = ( [ visibility ] as visibility attribute_definition_name [ attribute_type ] [ cardinality ] [ class_body ] ) as attributes
+  # Issue lutaml/lutaml#49: `as :element` / `as :attribute` picks the XML
+  # node kind of an attribute (lutaml-model map_element / map_attribute).
+  atomic xml_role_suffix = "as" 1*" " ":" ( ( "element" / "attribute" ) as xml_role )
+  attribute_definition = ( [ visibility ] as visibility attribute_definition_name [ attribute_type ] [ cardinality ] [ xml_role_suffix ] [ class_body ] ) as attributes
 
   keyword_type_argument = "type" ( 1*nonspace ) as type [ whitespace ]
   keyword_cardinality_argument = "cardinality" cardinality_body_definition as cardinality [ whitespace ]
@@ -154,7 +178,7 @@ grammar Lml version "1.0.0" {
   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 = ( kw_attribute_sp attribute_name keyword_attribute_body ) as attributes
+  keyword_attribute_definition = ( kw_attribute_sp attribute_name [ xml_role_suffix ] keyword_attribute_body ) as attributes
 
   # ---- Associations ----
   owner_cardinality = "[" cardinality_body_definition as owner_end_cardinality "]"
@@ -235,7 +259,10 @@ grammar Lml version "1.0.0" {
   string_format_body = "{" [ whitespace ] ( *( string_format_item ) ) as items [ whitespace ] "}"
   string_format_definition = ( [ whitespace ] kw_string_format_sp ( variable ) as format string_format_body ) as string_format
 
-  class_inner_definitions = visibility_declaration / abstract_declaration / definition_body / definition_line / class_mapping_section / derive_definition / string_format_definition / ( operation_definition ) as operations / attribute_comma_definition / ( !( kw_attribute_sp ) attribute_definition ) / keyword_attribute_definition / comment_definition / comment_multiline_definition
+  # Issue lutaml/lutaml#49: a quoted `namespace "uri" [prefix "p"]` line
+  # inside a class declares the class's XML namespace.
+  class_namespace_definition = ( kw_namespace_sp ( quoted_string ) as uri [ kw_prefix_sp ( quoted_string / ( 1*word ) ) as prefix ] ) as class_namespace [ whitespace ]
+  class_inner_definitions = class_namespace_definition / visibility_declaration / abstract_declaration / definition_body / definition_line / class_mapping_section / derive_definition / string_format_definition / ( operation_definition ) as operations / attribute_comma_definition / ( !( kw_attribute_sp ) attribute_definition ) / keyword_attribute_definition / comment_definition / comment_multiline_definition
   class_inner_definition = class_inner_definitions [ whitespace ]
   class_body = "{" [ whitespace ] ( *( class_inner_definition ) ) as members "}"
   parent_class = "<" ( class_name_chars ) as parent_class

data/lib/lutaml/lml/model_compiler/serialization_mappings.rb

@@ -49,18 +49,40 @@ module Lutaml
           end
         end
 
+        # Default XML mapping: every attribute an element, except those
+        # declared `as :attribute`; an in-class `namespace "uri"` becomes
+        # the class's XML namespace (issue #49).
         def apply_xml_mapping(klass, root_name)
           attr_names = klass.attributes.keys
-          return if attr_names.empty?
-
+          def_obj = @class_defs[root_name]
+          roles = xml_roles_of(def_obj)
+          ns_class = inline_namespace_class(def_obj)
           klass.xml do |mapping|
             mapping.element(root_name)
+            mapping.namespace(ns_class) if ns_class
             attr_names.each do |attr_name|
-              mapping.map_element(attr_name.to_s, to: attr_name)
+              if roles[attr_name] == 'attribute'
+                mapping.map_attribute(attr_name.to_s, to: attr_name)
+              else
+                mapping.map_element(attr_name.to_s, to: attr_name)
+              end
             end
           end
         end
 
+        def xml_roles_of(def_obj)
+          Array(def_obj&.attributes).each_with_object({}) do |attr, roles|
+            roles[attr.name.to_sym] = attr.xml_role if attr.xml_role
+          end
+        end
+
+        def inline_namespace_class(def_obj)
+          decl = def_obj.xml_namespace if def_obj.is_a?(UmlClass)
+          return nil unless decl&.uri
+
+          build_namespace_class("#{decl.uri}|#{decl.prefix}", decl.uri, decl.prefix.to_s)
+        end
+
         # RS 3010 extension: key-value mapping blocks for the declared
         # formats (yaml/json/toml share lutaml-model's key_value model).
 
@@ -89,7 +111,7 @@ module Lutaml
           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)] }
+                           .to_h { |r| [r.field, namespace_class_for(r.field)] }
           klass.xml do |m|
             m.element(mapping.element_name) if mapping.element_name
             m.namespace(ns_class) if ns_class
@@ -149,12 +171,16 @@ module Lutaml
           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
+          build_namespace_class(ref, declared.uri, declared.prefix.to_s)
+        end
+
+        def build_namespace_class(key, uri, prefix)
+          require 'lutaml/xml/namespace' unless defined?(Lutaml::Xml::Namespace)
+
+          @namespace_classes[key] ||= Class.new(Lutaml::Xml::Namespace).tap do |ns_class|
+            ns_class.define_singleton_method(:uri) { uri }
+            ns_class.define_singleton_method(:prefix_default) { prefix }
+          end
         end
       end
     end

data/lib/lutaml/lml/model_compiler.rb

@@ -59,6 +59,7 @@ module Lutaml
         @declared_namespaces = []
         @serialization_mappings = []
         @namespace_classes = {}
+        @class_defs = {}
       end
 
       def compile(input)
@@ -140,6 +141,7 @@ module Lutaml
 
       def compile_class(klass_def)
         name = klass_def.name.to_s
+        @class_defs[name] = klass_def
         compiled_klass = build_compiled_class(klass_def)
         apply_declared_mappings(compiled_klass, klass_def)
         declare_derived_fields(compiled_klass, klass_def)
@@ -293,11 +295,17 @@ module Lutaml
 
       def register(name, klass)
         @compiled[name] = klass
-        return unless @namespace
+        return name_anonymous_class(klass, name) unless @namespace
 
         namespace_module.const_set(name, klass)
       end
 
+      # Without a target namespace the class stays anonymous, and
+      # lutaml-model's schema generators need a class name for $defs/$ref.
+      def name_anonymous_class(klass, name)
+        klass.define_singleton_method(:name) { name }
+      end
+
       def namespace_module
         return @namespace if @namespace.is_a?(Module)
 

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

@@ -24,6 +24,8 @@ module Lutaml
       attribute :default, :string
       attribute :value_set, :string, collection: true, default: -> { [] }
       attribute :pattern, :string
+      # `as :element` / `as :attribute`: the XML node kind (issue #49)
+      attribute :xml_role, :string
 
       # LML-specific attributes
       attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
@@ -60,6 +62,7 @@ module Lutaml
         map "default", to: :default
         map "value_set", to: :value_set
         map "pattern", to: :pattern
+        map "xml_role", to: :xml_role
         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

@@ -32,6 +32,8 @@ module Lutaml
       attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
 
       # LML-specific
+      # In-class `namespace "uri"` declaration (issue #49)
+      attribute :xml_namespace, "Lutaml::Lml::Namespace"
       attribute :parent_class, :string
 
       yaml do
@@ -42,6 +44,7 @@ module Lutaml
         map "stereotype", to: :stereotype
         map "visibility", to: :visibility
         map "type", to: :type
+        map "xml_namespace", to: :xml_namespace
         map "attributes", to: :attributes
         map "operations", to: :operations
         map "constraints", to: :constraints

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.3.4"
+    VERSION = "0.3.5"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-21 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.114
+        version: 0.8.156
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.8.114
+        version: 0.8.156
 - !ruby/object:Gem::Dependency
   name: parsanol
   requirement: !ruby/object:Gem::Requirement