lutaml-lml 0.1.8 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d249342f8fa771fc6acc926a4a4fa75eb2f2532ccd4461ea0452c7930d6a0372
-  data.tar.gz: 7a852a63a20c02124a7c34c66501f749801711968239ef8e7fd7d92df4b96abb
+  metadata.gz: 41662922310b1ec54e30485a3ec783c99f385f5e80eb0e4a98277b72ac5a71dc
+  data.tar.gz: 2b6030ded9c8bb82941ceefdf5e1df9a8531af5a61888faee4ecbc23df0ca961
 SHA512:
-  metadata.gz: 2acbed3dc1c0da892d6344ec7ff87147d13d24de03b44ae8c8ff3ba136a3941a20ac6b95e4d1e4445c52b91ca0997e1d7c9a7425fd92713b954874ce2dd0abf3
-  data.tar.gz: a9f5844e875eba16ef0f3bdcb2f10ff62fe377935cce06f35c7e92571a8e7cfa9a43782919b2661f161cb4be6fffe73b67fc10bbcb9c56a73ab7ec36b2daec48
+  metadata.gz: 94f5275ce72d247c2842a60b265bdc8980cf82b49ce45d1970b606a0a9329505776235efb2df3247165b40cd5aaccc977b9aadcf77eb4ad044119ec71e4ea0a7
+  data.tar.gz: bfe8561322f20e76736e00a6c67ab862207e344637097f270a1111c7a5edbc540f8137989858e8fe3584dbaded200fe150c35da83523a637d26523f9cc64f8e6

data/lib/lutaml/lml/cli.rb

@@ -37,7 +37,12 @@ module Lutaml
 
       def initialize(*args)
         super
-        @formatter = ::Lutaml::Formatter::Graphviz.new if defined?(::Lutaml::Formatter::Graphviz)
+        @formatter = case options[:layout]
+                     when 'elk'
+                       ::Lutaml::Formatter::Elk.new
+                     else
+                       ::Lutaml::Formatter::Graphviz.new
+                     end
         @out_object = $stdout
       end
 
@@ -71,6 +76,8 @@ module Lutaml
                            desc: 'Node attributes (key=value,key2=value2)'
       method_option :all, type: :string, aliases: '-a',
                           desc: 'Set attributes for graph, edge, and node'
+      method_option :layout, type: :string, enum: %w[graphviz elk], default: 'graphviz',
+                             desc: 'Layout engine (elk requires the elkrb gem)'
       def generate(*paths)
         assert_input_paths(paths)
 
@@ -186,13 +193,22 @@ module Lutaml
           input_path = Pathname.new(path_string)
           return report_file_error(input_path, 'File does not exist') unless input_path.exist?
 
-          parse_document(input_path)
-          say "✓ #{input_path}", :green
-          nil
+          document = parse_document(input_path)
+          violations = Lutaml::Lml::Validator.violations(document)
+          if violations.any?
+            report_file_error(input_path, violations_message(violations))
+          else
+            say "✓ #{input_path}", :green
+            nil
+          end
         rescue StandardError => e
           report_file_error(input_path, e.message)
         end
 
+        def violations_message(violations)
+          violations.map { |v| "[#{v.rule}] #{v.message}" }.join('; ')
+        end
+
         def report_file_error(input_path, message)
           say "✗ #{input_path}: #{message}", :red
           "#{input_path}: #{message}"

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

@@ -15,18 +15,52 @@ module Lutaml
 
         def process_attributes_array(obj)
           return [] if obj.empty?
-          return obj.map { |item| process_attributes(item) } unless single_key_hashes?(obj)
+          return obj.map { |item| process_attributes(item) } unless named_attribute_entries?(obj)
+          return merge_named_entries(obj) unless single_key_hashes?(obj)
 
+          obj.each_with_object({}) { |item, hash| append_uniform_entry(hash, item) }
+        end
+
+        def append_uniform_entry(hash, item)
+          hash[:properties] ||= []
+          if item.key?(:properties)
+            hash[:properties] << process_attributes(item[:properties])
+          else
+            hash.merge!(process_attributes(item))
+          end
+        end
+
+        # Attribute-definition groups split across capture depths (e.g. the
+        # comma form: {name, type} beside a nested {value_set}) combine into
+        # one attribute entry. Key/value pair lists (import/export maps)
+        # carry :key and are never merged.
+        def named_attribute_entries?(obj)
+          obj.any? { |e| e.is_a?(Hash) && e.key?(:name) } &&
+            obj.all? { |e| e.is_a?(Hash) && !e.key?(:key) }
+        end
+
+        COLLECTION_KEYS = %i[properties attributes instances].freeze
+
+        def merge_named_entries(obj)
           obj.each_with_object({}) do |item, hash|
-            hash[:properties] ||= []
-            if item.key?(:properties)
-              hash[:properties] << process_attributes(item[:properties])
-            else
-              hash.merge!(process_attributes(item))
+            process_attributes(item).each do |key, value|
+              hash[key] = merge_attribute_value(hash[key], key, value)
             end
           end
         end
 
+        def merge_attribute_value(existing, key, value)
+          return merge_collection_value(existing, value) if COLLECTION_KEYS.include?(key)
+          return existing + value if existing.is_a?(Array) && value.is_a?(Array)
+
+          value
+        end
+
+        def merge_collection_value(existing, value)
+          current = existing.is_a?(Array) ? existing : (existing ? [existing] : [])
+          current + (value.is_a?(Array) ? value : [value])
+        end
+
         def process_attributes_hash(obj)
           result = extract_name_and_value(obj)
           convert_instance_type(result)
@@ -34,18 +68,17 @@ module Lutaml
           result[:literal] = true if obj.key?(:type_literal)
           apply_nested_attributes(result, obj)
           apply_remaining_keys(result, obj)
+          translate_values_argument(result)
           result
         end
 
-        private
-
         def single_key_hashes?(arr)
           arr.all? { |e| e.is_a?(Hash) && e.keys.size == 1 }
         end
 
         def extract_name_and_value(obj)
           result = {}
-          result[:name] = obj[:key] if obj.key?(:key)
+          result[:name] = strip_argument_colon(obj[:key]) if obj.key?(:key)
 
           if obj.key?(:comments)
             result[:name] = 'Comment'
@@ -74,9 +107,16 @@ module Lutaml
           obj.each do |key, value|
             next if EXCLUDED_PASS_THROUGH_KEYS.include?(key)
 
+            value = strip_argument_colon(value) if key == :name
             result[key] = value unless result.key?(key)
           end
         end
+
+        # `default: "Clear"` uses the colon separator (RS 3001 §Attribute);
+        # the colon lands in the captured name and must not.
+        def strip_argument_colon(name)
+          name.to_s.sub(/:\z/, "")
+        end
       end
     end
   end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    class DataProcessor
+      # RS 3001 §Value/§Attribute argument normalization: the canonical
+      # `value` construct and the attribute `values` argument.
+      module ValueDeclarationProcessing
+        # `value <name> { block }` is the canonical enum member; the bare
+        # identifier member is its documented shortcut. Normalize into the
+        # member shape the shortcut produces: the value block's `definition`
+        # lines become the member description and its attribute pairs become
+        # member payload properties.
+        def process_value_declaration(decl)
+          inner = { name: unwrap_string(decl[:value_name]) }
+          Array(decl[:members]).each do |member|
+            normalize_value_member(inner, member)
+          end
+          { attributes: inner }
+        end
+
+        # `values <enum>` types the attribute with the named enum;
+        # `values { v1, v2 }` carries an inline value set that the compiler
+        # expands into an anonymous enum.
+        def translate_values_argument(result)
+          if result.key?(:value_set_ref)
+            ref = unwrap_string(result.delete(:value_set_ref))
+            result[:type] = ref unless result[:type]
+          end
+          return unless result.key?(:value_set)
+
+          result[:value_set] = Array(result[:value_set][:items]).map { |item| unwrap_data_value(item[:item]) }
+        end
+
+        private
+
+        def normalize_value_member(inner, member)
+          if member.key?(:definition)
+            (inner[:attributes] ||= []) << { name: 'description', type: unwrap_string(member[:definition]) }
+          elsif member.key?(:instance)
+            (inner[:instances] ||= []).concat(Array(member[:instance]))
+          elsif member.key?(:attributes)
+            (inner[:properties] ||= []) << member[:attributes]
+          elsif member.key?(:key)
+            (inner[:properties] ||= []) << extract_name_and_value(member)
+          end
+        end
+
+        def unwrap_data_value(item)
+          return item unless item.is_a?(Hash)
+
+          item[:string] || item[:number] || item[:float] ||
+            item[:boolean] || item[:name] || item
+        end
+
+        def unwrap_string(value)
+          value.is_a?(Hash) && value.key?(:string) ? value[:string] : value
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/data_processor.rb

@@ -5,12 +5,14 @@ module Lutaml
     class DataProcessor
       autoload :ValueProcessing, "lutaml/lml/data_processor/value_processing"
       autoload :AttributeProcessing, "lutaml/lml/data_processor/attribute_processing"
+      autoload :ValueDeclarationProcessing, "lutaml/lml/data_processor/value_declaration_processing"
       autoload :InstanceProcessing, "lutaml/lml/data_processor/instance_processing"
       autoload :CollectionProcessing, "lutaml/lml/data_processor/collection_processing"
       autoload :ViewProcessing, "lutaml/lml/data_processor/view_processing"
 
       include ValueProcessing
       include AttributeProcessing
+      include ValueDeclarationProcessing
       include InstanceProcessing
       include CollectionProcessing
       include ViewProcessing
@@ -20,6 +22,7 @@ module Lutaml
         instances: :process_instances,
         instance: :process_instance,
         attributes: :process_attributes,
+        value_decl: :process_value_declaration,
         show_list: :process_show_list,
         hide_list: :process_hide_list
       }.freeze

data/lib/lutaml/lml/document_builder.rb

@@ -24,7 +24,9 @@ module Lutaml
         mapping: ::Lutaml::Lml::Mapping,
         string_format: ::Lutaml::Lml::StringFormat,
         derived_field: ::Lutaml::Lml::DerivedField,
-        member_field: ::Lutaml::Lml::MemberField
+        member_field: ::Lutaml::Lml::MemberField,
+        namespace: ::Lutaml::Lml::Namespace,
+        serialization_mapping: ::Lutaml::Lml::SerializationMapping
       }.freeze
 
       attr_reader :registry
@@ -36,7 +38,7 @@ module Lutaml
       FACTORY_KEYS = %i[
         document package class enum data_type diagram view_import view_filter
         attribute association operation constraint value cardinality mapping
-        string_format derived_field
+        string_format derived_field namespace serialization_mapping
       ].freeze
 
       MEMBER_KEY_MAP = {
@@ -52,7 +54,9 @@ module Lutaml
         constraints: :constraint,
         values: :value,
         mappings: :mapping,
-        member_fields: :member_field
+        member_fields: :member_field,
+        namespaces: :namespace,
+        serialization_mappings: :serialization_mapping
       }.freeze
 
       FACTORY_KEYS.each do |key|
@@ -68,6 +72,16 @@ module Lutaml
       def set_model(model, hash)
         hash = build_members(model, hash)
         set_model_attributes(model, hash)
+        expand_class_specializer(model, hash)
+      end
+
+      # The prefix specializer (`abstract class Foo`) expands to the
+      # canonical `abstract true` declaration (RS 3001 par. Declaration
+      # modifiers); the class-level modifier capture is not a block member.
+      def expand_class_specializer(model, hash)
+        return unless hash[:modifier].to_s == 'abstract' && model.class.attributes.key?(:is_abstract)
+
+        model.is_abstract = true
       end
 
       def set_model_attributes(model, hash)
@@ -79,12 +93,24 @@ module Lutaml
       def build_members(model, hash)
         members = hash.delete(:members)
         members.to_a.each do |member_hash|
+          record_model_version(model, member_hash)
           add_members(model, member_hash)
           set_model_attributes(model, member_hash)
         end
         hash
       end
 
+      # A `models <Name> version "x.y.z"` header travels with the block's
+      # member hash; the block itself flattens into the document, so the
+      # version is recorded on the document before the name is dropped.
+      def record_model_version(model, hash)
+        return unless model.class.attributes.key?(:model_versions)
+        return unless hash.key?(:version)
+
+        name = hash[:name].to_s
+        model.model_versions[name] = unquote(hash.delete(:version)).to_s
+      end
+
       def apply_attribute(model, key, value)
         return unless model.class.attributes.key?(key.to_sym)
 
@@ -102,9 +128,11 @@ module Lutaml
       end
 
       def add_members(model, hash)
-        expand_mapping_section(model, hash)
-        expand_class_declarations(model, hash)
-        expand_enum_member_fields(model, hash)
+        expand_declared_members(model, hash)
+        normalize_namespace_declaration(hash)
+        normalize_serialization_mapping(hash)
+        expand_instances_collection_name(hash)
+        expand_nested_members(model, hash)
         MEMBER_KEY_MAP.each do |plural_key, singular_key|
           data = hash.delete(plural_key)
           next if data.nil?
@@ -116,6 +144,185 @@ module Lutaml
         remap_filter_keys(hash, model)
       end
 
+      # RS 3001 §Enums: an enum-level `values { v1, v2 }` shorthand
+      # expands into plain members.
+      def expand_value_set_declaration(model, hash)
+        decl = hash.delete(:value_set_decl) or return
+        Array(decl[:items]).each do |item|
+          name = unquote(item[:item])
+          model.attributes << TopElementAttribute.new(name: name)
+        end
+      end
+
+      # RS 3001 §Value: the canonical `value` construct normalizes into
+      # the same member shape the bare-identifier shortcut produces.
+      def expand_value_declaration(model, hash)
+        decl = hash.delete(:value_decl) or return
+        apply_attribute(model, :attributes, decl.fetch(:attributes))
+      end
+
+      # Namespace declaration bodies arrive as keyword-line members
+      # ({uri: …}, {prefix: …}); flatten them onto the namespace hash.
+      def normalize_namespace_declaration(hash)
+        ns = hash[:namespaces] or return
+        Array(ns.delete(:members)).each do |pair|
+          pair.each { |key, value| ns[key] = unquote(value) }
+        end
+      end
+
+      # Serialization mapping rules arrive keyed by their line construct
+      # ({map_element: {wire:, field:}}); normalize into plain MappingRule
+      # hashes so the model cast lands typed rules.
+      def normalize_serialization_mapping(hash)
+        mapping = hash[:serialization_mappings] or return
+        rules = Array(mapping[:rules])
+        return if rules.any? && rules.all? { |e| e.is_a?(Hash) && e.key?(:kind) }
+
+        rules = rules.filter_map do |entry|
+          next nil unless entry.is_a?(Hash)
+
+          next { kind: 'map', wire: unquote(entry[:wire]), field: unquote(entry[:to]) } if entry[:wire] && entry[:to]
+
+          first_key = entry.keys.first
+          kind = first_key.to_s
+          body = entry[first_key] || {}
+          unless body.is_a?(Hash)
+            kind_n = normalize_mapping_kind(kind)
+            next nil if body.to_s.empty?
+
+            term = unquote(body)
+            next { kind: kind_n, wire: term, field: term } if %w[element attribute map].include?(kind_n)
+
+            if kind_n == 'namespace'
+              mapping[:namespace_ref] = term
+              next nil
+            end
+
+            next { kind: kind_n, field: term }
+          end
+          if kind == 'element_name'
+            mapping[:element_name] = unquote(body[:element_name])
+            next nil
+          end
+          if kind == 'map_namespace'
+            mapping[:namespace_ref] = unquote(body[:namespace_ref])
+            next nil
+          end
+          normalized = { kind: normalize_mapping_kind(kind) }
+          wire = body[:wire] || body[:element_wire]
+          normalized[:wire] = unquote(wire) if wire
+          field = body[:field] || body[:to_field] || body[:element_field] ||
+                  body[:attribute_field] || body[:to]
+          normalized[:field] = unquote(field) if field
+          normalized[:mode] = body[:mode] if body[:mode]
+          normalized[:namespace_ref] = unquote(body[:namespace_ref]) if body[:namespace_ref]
+          normalized
+        end
+        mapping[:rules] = rules
+      end
+
+      def normalize_mapping_kind(kind)
+        {
+          'map_element' => 'element', 'map_attribute' => 'attribute',
+          'map_content' => 'content', 'map_namespace' => 'namespace',
+          'map_key' => 'key', 'map_value' => 'value', 'map' => 'map',
+          'legacy_map' => 'map'
+        }.fetch(kind, kind)
+      end
+
+      # A named instances collection (`instances "Glazes" { ... }`) arrives
+      # with its name as a sibling of the collection body; move it inside
+      # so the InstanceCollection carries it.
+      def expand_instances_collection_name(hash)
+        return unless hash.key?(:instances) && hash.key?(:name)
+
+        name = unquote(hash.delete(:name))
+        body = hash[:instances].is_a?(Hash) ? hash[:instances] : {}
+        body[:name] = name unless body.key?(:name)
+      end
+
+      # The document root is a repetition of top-level constructs (RS 3001:
+      # documents interleave declarations), so models/packages blocks nest
+      # their members one level down; recurse into them.
+      def expand_nested_members(model, hash)
+        return unless hash.key?(:members)
+
+        members = hash.delete(:members)
+        members.to_a.each do |nested|
+          add_members(model, nested)
+          set_model_attributes(model, nested)
+        end
+      end
+
+      # Declaration-level member hooks: single-line definitions, canonical
+      # `value` members, mapping sections, class declarations, enum
+      # member_fields and from_table all arrive as bare member hashes.
+      def expand_declared_members(model, hash)
+        expand_abstract_declaration(model, hash)
+        expand_definition_text(model, hash)
+        expand_value_declaration(model, hash)
+        expand_value_set_declaration(model, hash)
+        expand_mapping_section(model, hash)
+        expand_class_declarations(model, hash)
+        expand_enum_member_fields(model, hash)
+        expand_from_table(model, hash)
+        expand_operation_members(model, hash)
+      end
+
+      # Operation members arrive with grammar capture names
+      # (`visibility_modifier`, `param_default`) and per-iteration
+      # stereotype hashes; normalize to the model's field names.
+      def expand_operation_members(model, hash)
+        ops = hash.delete(:operations)
+        return unless ops && model.class.attributes.key?(:operations)
+
+        Array(ops.is_a?(Hash) ? [ops] : ops).each do |op|
+          model.operations << build(:operation, normalize_operation_hash(op))
+        end
+      end
+
+      def normalize_operation_hash(op)
+        op = op.dup
+        if (vis = op.delete(:visibility_modifier))
+          op[:visibility] = Transform::VISIBILITY_MAP.fetch(vis.to_s, 'public')
+        end
+        stereo = op[:stereotype]
+        if stereo
+          items = stereo.is_a?(Array) ? stereo : [stereo]
+          op[:stereotype] = items.map { |x| x.is_a?(Hash) ? x[:stereotype].to_s : x.to_s }
+        end
+        params = op[:owned_parameter]
+        if params
+          list = params.is_a?(Array) ? params : [params]
+          op[:owned_parameter] = list.map { |param| normalize_operation_param(param) }
+        end
+        op
+      end
+
+      def normalize_operation_param(param)
+        param = param.dup
+        if (default = param.delete(:param_default))
+          param[:default] = default.is_a?(Hash) ? default[:string].to_s : default.to_s
+        end
+        param
+      end
+
+      # RS 3001 §Definition single-line form (`definition "text"`) arrives
+      # as a quoted-string capture; unwrap it for the entity's definition.
+      # RS 3001 declaration modifiers: `abstract true` maps onto the
+      # is_abstract field (the visibility declaration flows through the
+      # generic attribute path).
+      def expand_abstract_declaration(model, hash)
+        value = hash.delete(:abstract)
+        model.is_abstract = true if value.to_s == 'true' && model.class.attributes.key?(:is_abstract)
+      end
+
+      def expand_definition_text(model, hash)
+        return unless hash.key?(:definition) && model.class.attributes.key?(:definition)
+
+        model.definition = unquote(hash.delete(:definition))
+      end
+
       # A mapping section arrives as a bare member hash
       # { format:, maps: [{ wire:, to: }] }; expand to one Mapping entry
       # per map line, each carrying the format, and strip the section keys
@@ -158,6 +365,23 @@ module Lutaml
                                       type: unquote(derived[:type]))
       end
 
+      # L7a: from_table declares the enum's members as an artifact table
+      # { from_table_name:, from_table_artifact? } — expansion happens at
+      # compile time (deterministic materialization, no runtime data dep)
+      def expand_from_table(model, hash)
+        decl = hash.delete(:from_table_decl)
+        return unless decl && model.is_a?(Enum)
+
+        # the members repetition splits the declaration across iteration
+        # hashes (name part, artifact part) — merge the parts
+        parts = decl.is_a?(Array) ? decl : [decl]
+        decl = parts.each_with_object({}) do |part, acc|
+          acc.merge!(part) { |_key, _old, new_val| new_val }
+        end
+        model.from_table_name = unquote(decl[:from_table_name])
+        model.from_table_artifact = unquote(decl[:artifact_table]) if decl[:artifact_table]
+      end
+
       def expand_enum_member_fields(model, hash)
         decl = hash.delete(:member_fields_decl)
         return unless decl && model.is_a?(Enum)

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

@@ -70,6 +70,8 @@ module Lutaml
           end
 
           def format_value(prefix, key, value, indent)
+            return "#{prefix}#{key} = ref:(#{value[:reference]})" if reference_value?(value)
+
             case value
             when Array
               format_array(prefix, key, value, indent)
@@ -84,11 +86,15 @@ module Lutaml
 
           def format_array(prefix, key, items, indent)
             elements = items.map do |item|
-              case item
-              when Hash
-                format_nested_instance(item, indent + 1)
+              if reference_value?(item)
+                "  ref:(#{item[:reference]})"
               else
-                "  #{quote_value(item)}"
+                case item
+                when Hash
+                  format_nested_instance(item, indent + 1)
+                else
+                  "  #{quote_value(item)}"
+                end
               end
             end
 
@@ -111,6 +117,13 @@ module Lutaml
             "#{prefix}instance#{type_clause} {\n#{inner}\n#{prefix}}"
           end
 
+          # RS 3001 par. Value type: a `reference` map is the wire form of a
+          # reference literal; it emits as `ref:(path)`, never as a nested
+          # instance.
+          def reference_value?(value)
+            value.is_a?(Hash) && value.keys == [:reference]
+          end
+
           def quote_value(val)
             return val.to_s if val.is_a?(Numeric) || val.is_a?(TrueClass) || val.is_a?(FalseClass)
             str = val.to_s

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Formatter
+    # ELK-layout diagram formatter: builds an Elkrb::Graph from the
+    # document, lays it out in-process (no external tools) and emits SVG,
+    # or converts the SVG to PS/EPS/EMF through vectory.
+    class Elk
+      VALID_TYPES = %i[svg ps eps emf].freeze
+
+      attr_reader :type
+
+      def initialize(_attributes = {})
+        @type = :svg
+      end
+
+      def type=(value)
+        @type = value.to_sym
+        return if VALID_TYPES.include?(@type)
+
+        raise ArgumentError,
+              "unsupported output type #{@type.inspect} (valid: #{VALID_TYPES.join(', ')})"
+      end
+
+      def format(document)
+        graph = Lutaml::Layout::ElkGraphBuilder.new.build(document)
+        svg = Lutaml::Layout::ElkEngine.new(input: graph).render(:svg)
+        @type == :svg ? svg : convert(svg)
+      end
+
+      private
+
+      def convert(svg)
+        require 'vectory'
+        Vectory::Svg.new(svg).public_send(:"to_#{@type}").content
+      rescue LoadError
+        raise Error, 'The vectory gem is required for PS/EPS/EMF output: ' \
+                     'add `gem "vectory"` to your Gemfile'
+      end
+    end
+  end
+end

data/lib/lutaml/lml/formatter/graphviz/node_formatter.rb

@@ -7,7 +7,8 @@ module Lutaml
         ACCESS_SYMBOLS = {
           'public' => '+',
           'protected' => '#',
-          'private' => '-'
+          'private' => '-',
+          'package' => '~'
         }.freeze
 
         def format_attribute(node)

data/lib/lutaml/lml/formatter.rb

@@ -4,5 +4,6 @@ module Lutaml
   module Formatter
     autoload :Base, "lutaml/lml/formatter/base"
     autoload :Graphviz, "lutaml/lml/formatter/graphviz"
+    autoload :Elk, "lutaml/lml/formatter/elk"
   end
 end