lutaml-lml 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d0abfcd0323da47f7c05a6df8de6ddd2a17b91a6c022f2d503372bf9ad3ad62
-  data.tar.gz: 98a5f6ba03661fb78b761e590631aef8870171332cbebe9a51d173633fc1e4a5
+  metadata.gz: 848b5d75872b444720cee8fb6cdc2ae93db738657cb8ad13633d0317d8bd9808
+  data.tar.gz: f9718ba7428f4948d06bf8e489d55d78584c95086ebc4ff6ea6fb2bd0c0e41a9
 SHA512:
-  metadata.gz: 77d556ec76e8d1fc4d60b3d903211d39223f35ed04cbde561e812ca8eadd3ef93553364d36e404c59372add94eb24ca99132147446875eb2e47bebf1e9e90484
-  data.tar.gz: 8124cc37dac4d70ef905a1b8edb80d23acc40efe1d73496c15414250fb13d15f5dc86ebf576ff674b32d4aa3dd9e5ff69a1c7a33df558f56925813ca064aa035
+  metadata.gz: adae7746cdcf26e0709537239e7a4cc234c9287f49615eca76d44add023d11d317b30754ac9fef8d1dd6fbbc0899d19a77c284aa3726b6f8809b9f49ea440b4a
+  data.tar.gz: ac7189d5cef1e567485b38b56e23998961280600d157c037e8e21def73ee41e22f632ff82c0ab298c286319c00ab74d9a71e6d3fe0f4e9669ea8644cdd7b03ba

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/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.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

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,8 +19,11 @@ module Lutaml
           rule(:whitespace?) { whitespace.maybe }
           rule(:newline) { match('[\r\n]') }
 
+          rule(:quoted_string_content) do
+            (str('"').absent? >> any).repeat
+          end
           rule(:quoted_string) do
-            str('"') >> (str('"').absent? >> any).repeat.as(:string) >> str('"')
+            str('"') >> quoted_string_content.as(:string) >> str('"')
           end
           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) }

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

@@ -7,25 +7,45 @@ 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('"') >>
+            kw_view_import >>
+              str('"') >> quoted_string_content.as(:path) >> str('"') >>
               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/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"

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

@@ -7,10 +7,10 @@ module Lutaml
       attribute :name, :string
       attribute :title, :string
       attribute :caption, :string
-      attribute :groups, "Lutaml::Lml::Group", collection: true
+      attribute :groups, "Lutaml::Lml::Group", collection: true, default: -> { [] }
       attribute :fidelity, "Lutaml::Lml::Fidelity"
       attribute :fontname, :string
-      attribute :comments, :string, collection: true
+      attribute :comments, :string, collection: true, default: -> { [] }
 
       attribute :classes, "Lutaml::Lml::UmlClass", collection: true, default: -> { [] }
       attribute :data_types, "Lutaml::Lml::DataType", collection: true, default: -> { [] }
@@ -20,11 +20,12 @@ module Lutaml
       attribute :associations, "Lutaml::Lml::Association", collection: true, default: -> { [] }
       attribute :diagrams, "Lutaml::Lml::Diagram", collection: true, default: -> { [] }
 
-      # LML-specific
+      # LML-specific. instance/instances/fidelity/show_filter/hide_filter
+      # are deliberately default-less: nil means "absent".
       attribute :instance, "Lutaml::Lml::Instance"
-      attribute :requires, :string, collection: true
+      attribute :requires, :string, collection: true, default: -> { [] }
       attribute :instances, "Lutaml::Lml::InstanceCollection"
-      attribute :view_imports, "Lutaml::Lml::ViewImport", collection: true
+      attribute :view_imports, "Lutaml::Lml::ViewImport", collection: true, default: -> { [] }
       attribute :show_filter, "Lutaml::Lml::ViewFilter"
       attribute :hide_filter, "Lutaml::Lml::ViewFilter"
 
@@ -32,13 +33,13 @@ module Lutaml
       # formatters that need to walk every classifiable type without
       # caring which collection holds it.
       def all_classes
-        classes + enums + data_types + primitives
+        EntityTypes.all.flat_map { |type| public_send(type.entity_type) }
       end
 
       # Class-like entities that can own associations. Excludes enums
       # (which have no attributes/associations of their own).
       def classifiable_classes
-        classes + data_types + primitives
+        EntityTypes.classifiable.flat_map { |type| public_send(type.entity_type) }
       end
     end
   end

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

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

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

@@ -5,7 +5,7 @@ module Lutaml
     class Operation < 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/package.rb

@@ -5,7 +5,7 @@ module Lutaml
     class Package < 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/primitive_type.rb

@@ -7,7 +7,7 @@ module Lutaml
       # accesses the same attributes as DataType via format_class.
       attribute :name, :string
       attribute :keyword, :string, default: "primitive"
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :stereotype, :string, collection: true, default: -> { [] }
       attribute :visibility, :string, default: "public"
       attribute :is_abstract, :boolean, default: false
@@ -21,6 +21,10 @@ module Lutaml
       def self.entity_type
         :primitives
       end
+
+      def self.classifiable?
+        true
+      end
     end
   end
 end

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

@@ -16,16 +16,16 @@ module Lutaml
       attribute :is_static, :boolean, default: false
       attribute :is_read_only, :boolean, default: false
       attribute :stereotype, :string, collection: true, default: -> { [] }
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
       attribute :association, :string
       attribute :default, :string
 
       # LML-specific attributes
-      attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
-      attribute :value, "Lutaml::Lml::TopElementAttribute", collection: true
-      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: []
+      attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
+      attribute :value, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
+      attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
       attribute :extended, :boolean
-      attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
+      attribute :instances, "Lutaml::Lml::Instance", collection: true, default: -> { [] }
     end
   end
 end

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

@@ -3,9 +3,10 @@
 module Lutaml
   module Lml
     class UmlClass < Lutaml::Model::Serializable
-      # From TopElement
+      # From TopElement. TextType unescapes \{ \} and normalizes lines
+      # on every assignment (builder, yaml, direct).
       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"
@@ -31,9 +32,7 @@ module Lutaml
         map "name", to: :name
         map "keyword", to: :keyword
         map "is_abstract", to: :is_abstract
-        map "definition", to: :definition, with: {
-          to: :definition_to_yaml, from: :definition_from_yaml
-        }
+        map "definition", to: :definition
         map "modifier", to: :modifier
         map "stereotype", to: :stereotype
         map "visibility", to: :visibility
@@ -42,6 +41,9 @@ module Lutaml
         map "operations", to: :operations
         map "constraints", to: :constraints
         map "data_types", to: :data_types
+        # Owner-side defaulting is a parent-context rule ("an
+        # association nested under a class defaults its owner to that
+        # class"); only a mapping proc can see the containing model.
         map "associations", to: :associations, with: {
           to: :associations_to_yaml, from: :associations_from_yaml
         }
@@ -63,22 +65,13 @@ module Lutaml
         model.associations = associations
       end
 
-      def definition_to_yaml(model, doc)
-        doc["definition"] = model.definition if model.definition
-      end
-
-      def definition_from_yaml(model, value)
-        model.definition = value.to_s
-          .gsub(/\\}/, "}")
-          .gsub(/\\{/, "{")
-          .split("\n")
-          .map(&:strip)
-          .join("\n")
-      end
-
       def self.entity_type
         :classes
       end
+
+      def self.classifiable?
+        true
+      end
     end
   end
 end

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

@@ -6,7 +6,7 @@ module Lutaml
       attribute :name, :string
       attribute :id, :string
       attribute :type, :string
-      attribute :definition, :string
+      attribute :definition, Lutaml::Lml::Types::TextType
     end
   end
 end

data/lib/lutaml/lml/parser.rb

@@ -5,18 +5,13 @@ require "parslet/convenience"
 
 module Lutaml
   module Lml
+    # The Parslet parser: raw LML text → parse tree. Pipeline-level
+    # entry points live on the Lutaml::Lml module (parse /
+    # parse_document).
     class Parser < Parslet::Parser
       include Grammar::Full
 
       root(:diagram)
-
-      def self.parse(io)
-        Pipeline.call(io)
-      end
-
-      def self.parse_document(io)
-        Pipeline.call(io, resolve: false)
-      end
     end
   end
 end

data/lib/lutaml/lml/pipeline.rb

@@ -5,26 +5,24 @@ require "parslet/convenience"
 
 module Lutaml
   module Lml
+    # Parse pipeline only: preprocess → parse → transform → process →
+    # build. View resolution and label enrichment are a separate,
+    # explicit post-parse step (ViewResolution) — file I/O for imports
+    # does not belong inside parsing.
     class Pipeline
-      def self.call(input, resolve: true)
-        new(input, resolve: resolve).call
+      def self.call(input)
+        new(input).call
       end
 
-      def initialize(input, resolve: true)
-        @input = input
-        @resolve = resolve
+      def initialize(input)
+        @input = Source.wrap(input)
       end
 
       def call
         data = Preprocessor.call(@input)
         hash = parse_raw(data)
         hash = DataProcessor.process(hash)
-        document = build_document(hash)
-        if @resolve
-          document = resolve_document(document)
-          AssociationLabelResolver.new.enrich(document)
-        end
-        document
+        build_document(hash)
       end
 
       private
@@ -40,25 +38,6 @@ module Lutaml
       def build_document(hash)
         DocumentBuilder.new(DocumentBuilder::DEFAULT_REGISTRY).build(:document, hash)
       end
-
-      def resolve_document(document)
-        return document unless document.view_imports&.any?
-
-        base_path = @input.is_a?(StringIO) ? nil : @input.path
-        entities, associations = ImportResolver.new(base_path).resolve(document)
-        entities, associations = ViewResolver.new.resolve(document, entities, associations)
-        rebuild_document(document, entities, associations)
-      end
-
-      def rebuild_document(document, entities, associations)
-        grouped = entities.group_by { |e| e.class.entity_type }
-
-        document.classes = grouped[:classes] || []
-        document.enums = grouped[:enums] || []
-        document.data_types = grouped[:data_types] || []
-        document.associations = associations
-        document
-      end
     end
   end
 end

data/lib/lutaml/lml/preprocessor.rb

@@ -6,7 +6,7 @@ module Lutaml
       attr_reader :input_file
 
       def initialize(input_file)
-        @input_file = input_file
+        @input_file = Source.wrap(input_file)
       end
 
       class << self
@@ -16,37 +16,42 @@ module Lutaml
       end
 
       def call
-        input_file.rewind
-        include_root = input_file.is_a?(StringIO) ? Dir.pwd : File.dirname(input_file.path)
-        input_file.read.split("\n").reduce([]) do |res, line|
-          res.push(*process_dsl_line(include_root, line))
-        end.join("\n")
+        expand_lines(@input_file.read, @input_file.base_dir, [])
       end
 
       private
 
-      def process_dsl_line(include_root, line)
-        process_include_line(include_root, process_comment_line(line))
+      def expand_lines(text, base_dir, chain)
+        text.split(/\r?\n/)
+            .flat_map { |line| expand_line(line, base_dir, chain) }
+            .join("\n")
       end
 
-      def process_comment_line(line)
-        has_comment = line.match(%r{//.*})
-        return line if has_comment.nil?
+      def expand_line(line, base_dir, chain)
+        cleaned = strip_comment(line)
+        path = include_path(cleaned, base_dir)
+        return [cleaned] unless path
 
-        line.gsub(%r{//.*}, "")
+        raise Error, "circular include detected: #{path}" if chain.include?(path)
+
+        expand_lines(read_included(path), File.dirname(path), chain + [path])
       end
 
-      def process_include_line(include_root, line)
-        include_path_match = line.match(/^\s*include\s+(.+)/)
-        return line if include_path_match.nil?
+      def include_path(line, base_dir)
+        match = line.match(/^\s*include\s+(.+)/)
+        return nil unless match
 
-        path_to_file = File.expand_path(include_path_match[1].strip, include_root)
-        File.read(path_to_file).split("\n").map do |l|
-          process_comment_line(l)
-        end
+        File.expand_path(match[1].strip, base_dir)
+      end
+
+      def read_included(path)
+        File.read(path)
       rescue Errno::ENOENT, Errno::EACCES => e
-        warn "Skipping #{path_to_file}: #{e.message}"
-        []
+        raise Error, "cannot read include #{path}: #{e.message}"
+      end
+
+      def strip_comment(line)
+        line.sub(%r{//.*}, "")
       end
     end
   end

data/lib/lutaml/lml/source.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Lutaml
+  module Lml
+    # Normalizes pipeline input (String, StringIO, File, Tempfile) behind
+    # one interface: full text, filesystem path (or nil), and the
+    # directory imports/includes resolve against.
+    class Source
+      attr_reader :input
+
+      def self.wrap(input)
+        input.is_a?(Source) ? input : new(input)
+      end
+
+      def initialize(input)
+        @input = input
+      end
+
+      def read
+        return @input if @input.is_a?(String)
+
+        @input.rewind
+        @input.read
+      end
+
+      # Filesystem path, or nil for anonymous input (String/StringIO).
+      def path
+        io = unwrapped
+        io.is_a?(File) ? io.path : nil
+      end
+
+      def base_dir
+        path ? File.dirname(path) : Dir.pwd
+      end
+
+      private
+
+      # Tempfile delegates to File (it is not a File subclass on
+      # Ruby >= 3.4), so unwrap before type checks.
+      def unwrapped
+        io = @input
+        io = io.__getobj__ while io.is_a?(Delegator)
+        io
+      end
+    end
+  end
+end

data/lib/lutaml/lml/transform.rb

@@ -14,7 +14,11 @@ module Lutaml
       rule(visibility_modifier: simple(:visibility_value)) do
         VISIBILITY_MAP.fetch(visibility_value.to_s, 'public')
       end
-      rule(simple(:member)) { member.nil? ? member : member.to_s.strip }
+      # Global scalar normalizer: Parslet applies this to every leaf in
+      # the parse tree (names may legally contain trailing spaces via
+      # class_name_chars). Binding is named :value to make the breadth
+      # explicit — it is not tied to any one grammar rule.
+      rule(simple(:value)) { value.nil? ? value : value.to_s.strip }
     end
   end
 end

data/lib/lutaml/lml/types/text_type.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'lutaml/model'
+
+module Lutaml
+  module Lml
+    module Types
+      # LML `definition` body text. The grammar allows literal braces to
+      # be escaped (\{ \}) so they do not close the definition block;
+      # casting unescapes them and normalizes line indentation. One
+      # implementation shared by every attribute declared with this
+      # type — no per-model (de)serialization procs.
+      class TextType < Lutaml::Model::Type::String
+        def self.cast(value, options = {})
+          text = super
+          return nil if text.nil?
+          return text if Lutaml::Model::Utils.uninitialized?(text)
+
+          text.gsub(/\\}/, '}')
+              .gsub(/\\{/, '{')
+              .split("\n")
+              .map(&:strip)
+              .join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/lml/types.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Custom lutaml-model types shared by LML models.
+module Lutaml
+  module Lml
+    module Types
+      autoload :TextType, 'lutaml/lml/types/text_type'
+    end
+  end
+end

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.1.2"
+    VERSION = "0.1.3"
   end
 end

data/lib/lutaml/lml/view_resolution.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # Post-parse step: expand view imports, apply show/hide filters,
+    # rebuild the document's entity collections, and enrich association
+    # labels. Import expansion runs only when the document declares
+    # view imports; label enrichment always runs.
+    class ViewResolution
+      def self.call(document, base_dir)
+        document = resolve_imports(document, base_dir) if document.view_imports.any?
+        AssociationLabelResolver.new.enrich(document)
+      end
+
+      def self.resolve_imports(document, base_dir)
+        entity_index, associations = ImportResolver.new(base_dir).resolve(document)
+        entities, associations = ViewResolver.new.resolve(document, entity_index, associations)
+        rebuild_document(document, entities, associations)
+      end
+
+      def self.rebuild_document(document, entities, associations)
+        grouped = entities.group_by { |e| e.class.entity_type }
+
+        EntityTypes.symbols.each do |symbol|
+          document.public_send("#{symbol}=", grouped[symbol] || [])
+        end
+        document.associations = associations
+        document
+      end
+    end
+  end
+end

data/lib/lutaml/lml/view_resolver.rb

@@ -3,8 +3,9 @@
 module Lutaml
   module Lml
     class ViewResolver
-      def resolve(document, entities, associations)
-        visible = apply_filters(document, entities)
+      # entity_index is the ImportResolver's name → entity map.
+      def resolve(document, entity_index, associations)
+        visible = apply_filters(document, entity_index)
         filtered_associations = filter_associations(associations, visible)
 
         [visible, filtered_associations]
@@ -12,9 +13,8 @@ module Lutaml
 
       private
 
-      def apply_filters(document, entities)
-        names = entities.each_with_object({}) { |e, h| h[e.name] = e }
-
+      def apply_filters(document, entity_index)
+        names = entity_index.reject { |name, _| name.nil? }
         names = apply_show_filter(names, document.show_filter)
         names = apply_hide_filter(names, document.hide_filter)
 

data/lib/lutaml/lml.rb

@@ -14,21 +14,38 @@ module Lutaml
   module Lml
     class Error < Lutaml::Error; end
     class ParsingError < Error; end
+    class ImportError < Error; end
 
     def self.compile(input, namespace: nil)
       ModelCompiler.new(namespace: namespace).compile(input)
     end
 
+    # Full entry point: parse, then resolve view imports and enrich
+    # association labels.
+    def self.parse(input)
+      source = Source.wrap(input)
+      document = Pipeline.call(source)
+      ViewResolution.call(document, source.base_dir)
+    end
+
+    # Parse only — no import resolution, no label enrichment.
+    def self.parse_document(input)
+      Pipeline.call(input)
+    end
+
     # Top-level autoloads
     autoload :Parser, "lutaml/lml/parser"
     autoload :Pipeline, "lutaml/lml/pipeline"
     autoload :Preprocessor, "lutaml/lml/preprocessor"
+    autoload :Source, "lutaml/lml/source"
     autoload :Transform, "lutaml/lml/transform"
     autoload :DataProcessor, "lutaml/lml/data_processor"
     autoload :DocumentBuilder, "lutaml/lml/document_builder"
     autoload :ModelCompiler, "lutaml/lml/model_compiler"
     autoload :ImportResolver, "lutaml/lml/import_resolver"
     autoload :ViewResolver, "lutaml/lml/view_resolver"
+    autoload :ViewResolution, "lutaml/lml/view_resolution"
+    autoload :EntityTypes, "lutaml/lml/entity_types"
     autoload :AssociationLabelResolver, "lutaml/lml/association_label_resolver"
     autoload :Executor, "lutaml/lml/executor"
     autoload :YamlParser, "lutaml/lml/yaml_parser"
@@ -64,5 +81,6 @@ module Lutaml
     # Namespaces with their own autoloads
     autoload :Grammar, "lutaml/lml/grammar"
     autoload :Format, "lutaml/lml/format"
+    autoload :Types, "lutaml/lml/types"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-18 00:00:00.000000000 Z
+date: 2026-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -87,6 +87,7 @@ files:
 - lib/lutaml/lml/data_processor/value_processing.rb
 - lib/lutaml/lml/data_processor/view_processing.rb
 - lib/lutaml/lml/document_builder.rb
+- lib/lutaml/lml/entity_types.rb
 - lib/lutaml/lml/executor.rb
 - lib/lutaml/lml/executor/adapter_helpers.rb
 - lib/lutaml/lml/executor/condition_evaluator.rb
@@ -150,8 +151,12 @@ files:
 - lib/lutaml/lml/parser.rb
 - lib/lutaml/lml/pipeline.rb
 - lib/lutaml/lml/preprocessor.rb
+- lib/lutaml/lml/source.rb
 - lib/lutaml/lml/transform.rb
+- lib/lutaml/lml/types.rb
+- lib/lutaml/lml/types/text_type.rb
 - lib/lutaml/lml/version.rb
+- lib/lutaml/lml/view_resolution.rb
 - lib/lutaml/lml/view_resolver.rb
 - lib/lutaml/lml/yaml_parser.rb
 homepage: https://github.com/lutaml/lutaml-lml