lutaml-lml 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0abfcd0323da47f7c05a6df8de6ddd2a17b91a6c022f2d503372bf9ad3ad62
-  data.tar.gz: 98a5f6ba03661fb78b761e590631aef8870171332cbebe9a51d173633fc1e4a5
+  metadata.gz: f72188a69457d2cf82445867f2b726dd621d63e82d79c7e56b01241e0d15ec84
+  data.tar.gz: 402135ddb2bf31953c21f6166c859c6b5f67d24d1a9e18e8369eb3646a413381
 SHA512:
-  metadata.gz: 77d556ec76e8d1fc4d60b3d903211d39223f35ed04cbde561e812ca8eadd3ef93553364d36e404c59372add94eb24ca99132147446875eb2e47bebf1e9e90484
-  data.tar.gz: 8124cc37dac4d70ef905a1b8edb80d23acc40efe1d73496c15414250fb13d15f5dc86ebf576ff674b32d4aa3dd9e5ff69a1c7a33df558f56925813ca064aa035
+  metadata.gz: d07e5279b6c0d983d1ba1384ef3579aa3d493fba0520aedadfd97ac11a42bfca1fd2e96e621e6551e8dd22bef52e30136779cdf88e8bbe81e611b762e1efa3cd
+  data.tar.gz: 20e402c37d1506fd86c4ded5fac0bb010dc58d3cdda8efcf3e92cd287ec8025331375310b7e40093741af136aaaf4f61d78a44456fe59b2d75dffe5e1d57568b

data/lib/lutaml/lml/cli.rb

@@ -24,7 +24,7 @@ module Lutaml
       }.freeze
 
       PARSE_HANDLERS = {
-        'lutaml' => ->(path) { Lutaml::Lml::Parser.parse(File.new(path)) },
+        'lutaml' => ->(path) { Lutaml::Lml.parse(File.new(path)) },
         'yaml' => ->(path) { Lutaml::Lml::YamlParser.parse(path.to_s) },
         'yml' => ->(path) { Lutaml::Lml::YamlParser.parse(path.to_s) },
         'exp' => lambda { |path|

data/lib/lutaml/lml/data_processor/attribute_processing.rb

@@ -14,6 +14,7 @@ module Lutaml
         end
 
         def process_attributes_array(obj)
+          return [] if obj.empty?
           return obj.map { |item| process_attributes(item) } unless single_key_hashes?(obj)
 
           obj.each_with_object({}) do |item, hash|

data/lib/lutaml/lml/data_processor/instance_processing.rb

@@ -26,8 +26,7 @@ module Lutaml
             key = INSTANCE_KEY_HANDLERS.keys.find { |k| instance.key?(k) }
             next unless key
 
-            result = public_send(INSTANCE_KEY_HANDLERS[key], instance[key])
-            key == :instance ? (acc[:instances] << result) : (acc[key] = result)
+            append_result(acc, key, public_send(INSTANCE_KEY_HANDLERS[key], instance[key]))
           end
         end
 
@@ -57,6 +56,16 @@ module Lutaml
         def handle_instance_template(value, result)
           result[:template] = process_attributes(value[:attributes])
         end
+
+        private
+
+        def append_result(acc, key, result)
+          case key
+          when :instance then acc[:instances] << result
+          when :collections then (acc[:collections] ||= []) << result
+          else (acc[key] ||= []).concat(result)
+          end
+        end
       end
     end
   end

data/lib/lutaml/lml/data_processor/view_processing.rb

@@ -4,20 +4,21 @@ module Lutaml
   module Lml
     class DataProcessor
       module ViewProcessing
+        # entity_name_list parses to a Hash (one name) or an Array of
+        # Hashes (several); normalize both to one list of strings.
         def process_show_list(data)
-          extract_entity_names(data)
+          entity_names_from(data)
         end
 
         def process_hide_list(data)
-          extract_entity_names(data)
+          entity_names_from(data)
         end
 
         private
 
-        def extract_entity_names(data)
-          return data.map { |d| extract_entity_names(d) } if data.is_a?(Array)
-          return data[:entity_name].to_s if data.is_a?(Hash) && data.key?(:entity_name)
-          data.to_s
+        def entity_names_from(data)
+          entries = data.is_a?(Array) ? data : [data]
+          entries.map { |entry| entry[:entity_name].to_s }
         end
       end
     end

data/lib/lutaml/lml/document_builder.rb

@@ -65,7 +65,6 @@ module Lutaml
 
       def set_model_attributes(model, hash)
         hash.each do |key, value|
-          value = sanitize_definition(value) if key == :definition
           apply_attribute(model, key, value)
         end
       end
@@ -79,11 +78,6 @@ module Lutaml
         hash
       end
 
-      def sanitize_definition(value)
-        value.to_s.gsub(/\\}/, '}').gsub(/\\{/, '{')
-             .split("\n").map(&:strip).join("\n")
-      end
-
       def apply_attribute(model, key, value)
         return unless model.class.attributes.key?(key.to_sym)
 
@@ -131,8 +125,7 @@ module Lutaml
       end
 
       def build_view_filter(entity_names)
-        names = entity_names.is_a?(Array) ? entity_names : [entity_names]
-        ViewFilter.new(entity_names: names.map(&:to_s))
+        ViewFilter.new(entity_names: Array(entity_names).map(&:to_s))
       end
     end
   end

data/lib/lutaml/lml/entity_types.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # Single source of truth for entity types held on a Document. Each
+    # entity model declares self.entity_type (the Document collection
+    # name); consumers iterate this registry instead of hardcoding the
+    # type list in four places.
+    module EntityTypes
+      ALL = [UmlClass, Enum, DataType, PrimitiveType].freeze
+
+      def self.all
+        ALL
+      end
+
+      def self.by_symbol
+        @by_symbol ||= ALL.each_with_object({}) { |klass, index| index[klass.entity_type] = klass }
+      end
+
+      def self.symbols
+        by_symbol.keys
+      end
+
+      # Entities that can own attributes/associations (excludes enums).
+      def self.classifiable
+        ALL.select(&:classifiable?)
+      end
+    end
+  end
+end

data/lib/lutaml/lml/executor/condition_evaluator.rb

@@ -30,8 +30,8 @@ module Lutaml
         # Evaluate all validation conditions against a collection of instances.
         # Returns an array of error strings (empty if all pass).
         def self.evaluate(collection, instances)
-          return [] unless collection.validations&.any?
           return [] unless collection.is_a?(Collection)
+          return [] unless collection.validations&.any?
 
           new(instances).evaluate_all(collection.validations)
         end

data/lib/lutaml/lml/executor.rb

@@ -13,7 +13,7 @@ module Lutaml
     #
     # Usage:
     #   compiled = ModelCompiler.new.compile(models_file)
-    #   doc = Pipeline.call(instances_file, resolve: false)
+    #   doc = Lutaml::Lml.parse_document(instances_file)
     #   result = Executor.run(doc, compiled: compiled)
     #   result.instances  # array of hydrated instance objects
     #   result.errors     # array of validation error strings
@@ -73,10 +73,9 @@ module Lutaml
       def validate_collections(doc, instances)
         return [] unless doc.instances&.collections
 
-        collection = doc.instances.collections
-        return [] unless collection.is_a?(Collection)
-
-        ConditionEvaluator.evaluate(collection, instances)
+        Array(doc.instances.collections).flat_map do |collection|
+          ConditionEvaluator.evaluate(collection, instances)
+        end
       end
 
       # --- Export ---

data/lib/lutaml/lml/format/adapter/standard_adapter.rb

@@ -11,7 +11,7 @@ module Lutaml
             return data if data.is_a?(Hash)
 
             input = data.is_a?(IO) ? data : StringIO.new(data.to_s)
-            doc = Lutaml::Lml::Pipeline.call(input, resolve: false)
+            doc = Lutaml::Lml.parse_document(input)
             instance_to_hash(doc.instance)
           end
 

data/lib/lutaml/lml/formatter/base.rb

@@ -9,7 +9,7 @@ module Lutaml
 
       def find_by_name(name)
         name = name.to_sym
-        all.detect { |formatter_class| formatter_class.name == name }
+        all.detect { |formatter_class| formatter_class.formatter_name == name }
       end
     end
 
@@ -34,7 +34,10 @@ module Lutaml
           new(attributes).format(node)
         end
 
-        def name
+        # Registry key for Formatter.find_by_name. Deliberately not
+        # `name` — shadowing Class#name breaks Ruby internals and any
+        # library that legitimately calls .name on these classes.
+        def formatter_name
           to_s.split('::').last.downcase.to_sym
         end
       end
@@ -46,7 +49,7 @@ module Lutaml
       end
 
       def name
-        self.class.name
+        self.class.formatter_name
       end
 
       attr_reader :type
@@ -61,7 +64,7 @@ module Lutaml
 
       def dispatch_format(node)
         handler = FORMAT_HANDLERS.find { |type, _| node.is_a?(type) }&.last
-        return unless handler
+        raise Lml::Error, "no format handler for #{node.class}" unless handler
 
         public_send(handler, node)
       end

data/lib/lutaml/lml/grammar/concerns/definitions.rb

@@ -55,13 +55,21 @@ module Lutaml
           end
 
           # -- Definition
+          # Balanced-brace body: nested "{...}" and "\"-escapes are allowed,
+          # so definition text can contain format templates like "ZB{code}".
+          rule(:definition_content) do
+            (
+              (str("\\") >> any) |
+                (str("{") >> definition_content >> str("}")) |
+                (str("}").absent? >> any)
+            ).repeat(0)
+          end
           rule(:definition_body) do
             spaces? >>
               str("definition") >>
               whitespace? >>
               str("{") >>
-              ((str("\\") >> any) | (str("}").absent? >> any))
-                .repeat.maybe.as(:definition) >>
+              definition_content.as(:definition) >>
               str("}")
           end
 
@@ -142,22 +150,20 @@ module Lutaml
           end
           rule(:diagram_definitions) { diagram_definition >> whitespace? }
 
+          # A model file: bare top-level definitions with no enclosing
+          # named block. Same inner grammar as a diagram body; labeled
+          # :members so the document builder sees document shape.
+          rule(:model_definitions) { diagram_inner_definition.repeat(1).as(:members) }
+
           # -- View (extends diagram with import/show/hide)
           rule(:view_keyword) { kw_view >> spaces? }
-          rule(:view_inner_definitions) do
-            title_definition |
-              caption_definition |
-              fontname_definition |
-              view_import.as(:view_imports) |
+          rule(:view_only_definitions) do
+            view_import.as(:view_imports) |
               show_directive |
-              hide_directive |
-              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
+              hide_directive
+          end
+          rule(:view_inner_definitions) do
+            view_only_definitions | diagram_inner_definitions
           end
           rule(:view_inner_definition) do
             view_inner_definitions >> whitespace?
@@ -176,17 +182,19 @@ module Lutaml
 
           # -- Metadata
           rule(:title_keyword) { kw_title >> spaces }
+          # Quoted titles/captions accept any character (parentheses, commas,
+          # Unicode). Unquoted form keeps a conservative charset.
           rule(:title_text) do
-            quotes? >>
-              match['a-zA-Z0-9_\- ,.:;'].repeat(1).as(:title) >>
-              quotes?
+            (str('"') >> (str('"').absent? >> any).repeat(1).as(:title) >> str('"')) |
+              (str("'") >> (str("'").absent? >> any).repeat(1).as(:title) >> str("'")) |
+              match['a-zA-Z0-9_\- ,.:;()+\'/'].repeat(1).as(:title)
           end
           rule(:title_definition) { title_keyword >> title_text }
           rule(:caption_keyword) { kw_caption >> spaces }
           rule(:caption_text) do
-            quotes? >>
-              match['a-zA-Z0-9_\- ,.:;'].repeat(1).as(:caption) >>
-              quotes?
+            (str('"') >> (str('"').absent? >> any).repeat(1).as(:caption) >> str('"')) |
+              (str("'") >> (str("'").absent? >> any).repeat(1).as(:caption) >> str("'")) |
+              match['a-zA-Z0-9_\- ,.:;()+\'/'].repeat(1).as(:caption)
           end
           rule(:caption_definition) { caption_keyword >> caption_text }
 

data/lib/lutaml/lml/grammar/concerns/primitives.rb

@@ -19,9 +19,18 @@ module Lutaml
           rule(:whitespace?) { whitespace.maybe }
           rule(:newline) { match('[\r\n]') }
 
-          rule(:quoted_string) do
-            str('"') >> (str('"').absent? >> any).repeat.as(:string) >> str('"')
+          # Body of a string delimited by `char`, captured as `label`.
+          def quoted(char, label)
+            str(char) >> (str(char).absent? >> any).repeat.as(label) >> str(char)
           end
+
+          # A string in either quote style. Delimiters must match, so `"a'`
+          # stays a parse error.
+          def any_quoted(label)
+            quoted('"', label) | quoted("'", label)
+          end
+
+          rule(:quoted_string) { any_quoted(:string) }
           rule(:boolean) { (str("true") | str("false")).as(:boolean) }
           rule(:number) { (match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)).as(:float) | match("[0-9]").repeat(1).as(:number) }
           rule(:variable) { (quoted_string | match("[a-zA-Z0-9_]").repeat(1)) }

data/lib/lutaml/lml/grammar/concerns/view_rules.rb

@@ -7,25 +7,43 @@ module Lutaml
         module ViewRules
           include Parslet
 
-          rule(:view_import_keyword) { str("import") >> spaces }
+          # View-scoped keyword rules. `import` is named view_import to
+          # stay MECE with the instances-block kw_import keyword. The
+          # trailing `spaces` is the word boundary: `important` fails to
+          # match rather than parsing as `import`.
+          VIEW_KEYWORDS = {
+            "view_import" => "import",
+            "show" => "show",
+            "hide" => "hide",
+          }.freeze
+
+          VIEW_KEYWORDS.each do |rule_name, keyword|
+            rule("kw_#{rule_name}") { whitespace? >> str(keyword) >> spaces }
+          end
 
           rule(:view_import) do
-            view_import_keyword >>
-              str('"') >> (str('"').absent? >> any).repeat.as(:path) >> str('"') >>
-              whitespace?
+            kw_view_import >> any_quoted(:path) >> whitespace?
+          end
+
+          # Entity names in show/hide lists must be space-free: general
+          # class_name_chars allows spaces, which would swallow a
+          # following directive (`show Foo, Bar hide Baz` would parse
+          # "Bar hide Baz" as one name).
+          rule(:entity_name_atom) do
+            match('[a-zA-Z0-9_.:\-]').repeat(1).as(:entity_name)
           end
 
           rule(:entity_name_list) do
-            class_name.as(:entity_name) >>
-              (spaces? >> str(",") >> spaces? >> class_name.as(:entity_name)).repeat
+            entity_name_atom >>
+              (spaces? >> str(",") >> spaces? >> entity_name_atom).repeat
           end
 
           rule(:show_directive) do
-            str("show") >> spaces >> entity_name_list.as(:show_list) >> whitespace?
+            kw_show >> entity_name_list.as(:show_list) >> whitespace?
           end
 
           rule(:hide_directive) do
-            str("hide") >> spaces >> entity_name_list.as(:hide_list) >> whitespace?
+            kw_hide >> entity_name_list.as(:hide_list) >> whitespace?
           end
         end
       end

data/lib/lutaml/lml/grammar/instances.rb

@@ -30,8 +30,11 @@ module Lutaml
           rule("kw_#{keyword}") { whitespace? >> str(keyword) }
         end
 
-        # -- Root (Full: diagram + models + instances)
-        rule(:diagram) { require_block? >> (models | diagram_definitions | view_definitions | instances | instance) }
+        # -- Root (Full: diagram + models + instances + bare model files)
+        rule(:diagram) do
+          require_block? >>
+            (models | diagram_definitions | view_definitions | instances | instance | model_definitions)
+        end
       end
     end
   end

data/lib/lutaml/lml/import_resolver.rb

@@ -5,83 +5,81 @@ require "set"
 module Lutaml
   module Lml
     class ImportResolver
-      def initialize(base_path)
-        @base_path = base_path
+      def initialize(base_dir)
+        @base_dir = base_dir
       end
 
+      # Returns [entity_index, associations] where entity_index maps
+      # entity name → entity. ViewResolver consumes the index without
+      # rebuilding it.
       def resolve(document)
-        entities = {}
+        @failures = []
+        entity_index = {}
         associations = []
         visited = Set.new
 
         document.view_imports.each do |import|
-          resolve_import(import.path, entities, associations, visited, @base_path)
+          resolve_import(import.path, entity_index, associations, visited, @base_dir)
         end
 
-        collect_local_entities(document, entities, associations)
+        collect_local_entities(document, entity_index, associations)
 
-        [entities.values, associations]
+        raise ImportError, @failures.join("\n") if @failures.any?
+
+        [entity_index, associations]
       end
 
       private
 
-      def resolve_import(path, entities, associations, visited, base_path)
-        base_dir = base_path ? File.dirname(base_path) : Dir.pwd
+      def resolve_import(path, entity_index, associations, visited, base_dir)
         abs_pattern = File.expand_path(path, base_dir)
+        files = Dir.glob(abs_pattern)
+        if files.empty?
+          @failures << "import matched no files: #{path} (resolved to #{abs_pattern})"
+        end
 
-        Dir.glob(abs_pattern).each do |file_path|
+        files.each do |file_path|
           next if visited.include?(file_path)
           visited.add(file_path)
 
-          if view_file?(file_path)
-            resolve_view_file(file_path, entities, associations, visited)
-          else
-            resolve_model_file(file_path, entities, associations)
+          doc = parse_file(file_path)
+          collect_local_entities(doc, entity_index, associations)
+
+          doc.view_imports.each do |import|
+            resolve_import(import.path, entity_index, associations, visited, File.dirname(file_path))
           end
         end
       end
 
-      def resolve_view_file(file_path, entities, associations, visited)
-        doc = Parser.parse_document(File.new(file_path))
-
-        collect_local_entities(doc, entities, associations)
-
-        doc.view_imports&.each do |import|
-          resolve_import(import.path, entities, associations, visited, file_path)
-        end
+      # The grammar root accepts every file shape (diagram, view,
+      # models block, bare definitions) — no content sniffing needed.
+      def parse_file(file_path)
+        File.open(file_path) { |file| Pipeline.call(file) }
       rescue Errno::ENOENT, Errno::EACCES => e
-        warn "Skipping #{file_path}: #{e.message}"
-        []
+        @failures << "cannot read import #{file_path}: #{e.message}"
+        Document.new
       end
 
-      def resolve_model_file(file_path, entities, associations)
-        content = File.read(file_path)
-        wrapped = "diagram Fragment {\n#{content}\n}"
-        doc = Parser.parse_document(StringIO.new(wrapped))
-
-        collect_local_entities(doc, entities, associations)
-      rescue Errno::ENOENT, Errno::EACCES => e
-        warn "Skipping #{file_path}: #{e.message}"
-        []
-      end
-
-      def view_file?(file_path)
-        head = File.read(file_path, 200, encoding: "UTF-8")
-        head.match?(/\b(view|diagram)\s+\w/)
-      rescue Errno::ENOENT, Errno::EACCES
-        false
-      end
-
-      def collect_local_entities(doc, entities, associations)
-        merge_entities(doc.classes, entities)
-        merge_entities(doc.enums, entities)
-        merge_entities(doc.data_types, entities)
+      def collect_local_entities(doc, entity_index, associations)
+        EntityTypes.all.each do |type|
+          merge_entities(doc.public_send(type.entity_type), entity_index)
+        end
         associations.concat(doc.associations.to_a)
       end
 
-      def merge_entities(collection, entities)
+      # Re-importing the same entity through two paths is legitimate
+      # (dedup silently); the same name with different content is a
+      # conflict that must not resolve to a silently wrong diagram.
+      def merge_entities(collection, entity_index)
         collection.each do |entity|
-          entities[entity.name] ||= entity
+          next if entity.name.nil?
+
+          existing = entity_index[entity.name]
+          if existing.nil?
+            entity_index[entity.name] = entity
+          elsif existing.to_hash != entity.to_hash
+            @failures << "entity '#{entity.name}' is defined differently in two imports"
+          end
         end
       end
     end

data/lib/lutaml/lml/literal_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Lutaml
+  module Lml
+    # The type of an LML attribute literal: a scalar, a list, or a map.
+    #
+    # This exists as a subclass rather than using Lutaml::Model::Type::Value
+    # directly because lutaml-model's key-value serializer tests the declared
+    # attribute type with a strict `attribute_type < Type::Value`. Type::Value
+    # is not a strict subclass of itself, so declaring it hands the serializer
+    # the raw wrapper object: JSON calls to_json(state) on it and raises
+    # ArgumentError, and Psych emits a !ruby/object tag that from_yaml then
+    # refuses to load. A subclass puts the attribute on the working path, where
+    # the serializer asks the wrapper for its value instead.
+    #
+    # Deleting this class needs two upstream changes, not one: that `<` widened
+    # to `<=`, and the serializer no longer re-wrapping a value it already
+    # wrapped. Widening `<` alone still leaves the nested wrapper below.
+    class LiteralValue < Lutaml::Model::Type::Value
+      # The serializer re-wraps an already-wrapped value before asking it for a
+      # format, so #value has to see through that extra layer. Every to_<format>
+      # method lutaml-model generates reads through here, which is why this is
+      # one override rather than one per format.
+      def value
+        wrapped = super
+        wrapped.is_a?(LiteralValue) ? wrapped.value : wrapped
+      end
+    end
+  end
+end

data/lib/lutaml/lml/model_compiler.rb

@@ -15,7 +15,6 @@ module Lutaml
         "DateTime" => :date_time,
         "Time" => :time,
         "Uri" => :string,
-        "Hash" => :hash,
       }.freeze
 
       # Tokens that denote unbounded cardinality in LML attribute
@@ -30,13 +29,13 @@ module Lutaml
       end
 
       def compile(input)
-        doc = Pipeline.call(input, resolve: false)
+        doc = Lutaml::Lml.parse_document(input)
         compile_document(doc)
         @compiled
       end
 
       def hydrate(input)
-        doc = input.is_a?(Document) ? input : Pipeline.call(input, resolve: false)
+        doc = input.is_a?(Document) ? input : Lutaml::Lml.parse_document(input)
         compile_document(doc) unless @compiled.any?
         return {} unless doc.instance
 
@@ -56,7 +55,7 @@ module Lutaml
       #
       # Returns an array of validation error strings (empty if all pass).
       def validate(input, compiled: nil)
-        doc = input.is_a?(Document) ? input : Pipeline.call(input, resolve: false)
+        doc = input.is_a?(Document) ? input : Lutaml::Lml.parse_document(input)
         if compiled
           @compiled = compiled
         else

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

@@ -5,7 +5,7 @@ module Lutaml
     class Association < Lutaml::Model::Serializable
       # From TopElement
       attribute :name, :string
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :visibility, :string, default: "public"

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

@@ -5,7 +5,7 @@ module Lutaml
     class Constraint < Lutaml::Model::Serializable
       # From TopElement
       attribute :name, :string
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :visibility, :string, default: "public"

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

@@ -5,7 +5,7 @@ module Lutaml
     class DataType < Lutaml::Model::Serializable
       # From TopElement
       attribute :name, :string
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string, default: "dataType"
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :visibility, :string, default: "public"
@@ -26,6 +26,10 @@ module Lutaml
       def self.entity_type
         :data_types
       end
+
+      def self.classifiable?
+        true
+      end
     end
   end
 end

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

@@ -4,7 +4,7 @@ module Lutaml
   module Lml
     class Diagram < Lutaml::Model::Serializable
       attribute :name, :string
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :keyword, :string
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :visibility, :string, default: "public"