lutaml-lml 0.1.2 → 0.1.4

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

@@ -6,7 +6,7 @@ module Lutaml
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
       attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []
       attribute :exports, "Lutaml::Lml::InstancesExport", collection: true, default: []
-      attribute :collections, "Lutaml::Lml::Collection", default: []
+      attribute :collections, "Lutaml::Lml::Collection", collection: true, default: []
     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,79 @@ 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, LiteralValue
+      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: -> { [] }
+
+      # Declared in full because a mapping block replaces the defaults. The
+      # rules below are the defaults, 1:1, except for `value`.
+      #
+      # `value` needs custom methods because a list literal reaches the model
+      # as a bare Array, and lutaml-model refuses one on a non-collection
+      # attribute: Attribute#cast splits it, then valid_collection! raises
+      # CollectionTrueMissingError. A custom `from` returns before that check,
+      # so a non-empty list survives a round trip without changing the
+      # serialized form. An empty list still does not: the transform skips a
+      # blank value before reaching the custom method, so `[]` reloads as nil.
+      key_value do
+        map "name", to: :name
+        map "visibility", to: :visibility
+        map "type", to: :type
+        map "id", to: :id
+        map "contain", to: :contain
+        map "static", to: :static
+        map "cardinality", to: :cardinality
+        map "keyword", to: :keyword
+        map "is_derived", to: :is_derived
+        map "is_static", to: :is_static
+        map "is_read_only", to: :is_read_only
+        map "stereotype", to: :stereotype
+        map "definition", to: :definition
+        map "association", to: :association
+        map "default", to: :default
+        map "properties", to: :properties
+        map "value", to: :value, with: { to: :value_to, from: :value_from }
+        map "attributes", to: :attributes
+        map "extended", to: :extended
+        map "instances", to: :instances
+      end
+
+      # Public because lutaml-model invokes mapping methods via public_send.
+      #
+      # Skipping nil keeps the key out of the output, which is what the default
+      # mapping does. `false` is a real literal, so the guard tests for nil
+      # rather than truthiness.
+      def value_to(model, doc)
+        literal = model.value
+        return if literal.nil?
+
+        doc["value"] = unwrap_literal(literal)
+      end
+
+      # lutaml-model runs this on a throwaway mapper instance, so `self` is not
+      # the object being deserialized - `model` is. Writing to `self.value`
+      # here would update an object that is discarded a moment later.
+      def value_from(model, value)
+        model.value = value
+      end
+
+      private
+
+      # A LiteralValue sits at the top level for a map literal, and inside the
+      # array for a list of references. Writing one through unwrapped raises
+      # ArgumentError in the adapter.
+      def unwrap_literal(value)
+        return value.map { |item| unwrap_literal(item) } if value.is_a?(::Array)
+
+        value.is_a?(LiteralValue) ? value.value : value
+      end
     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.4"
   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,27 +14,47 @@ 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"
     autoload :HasAttributes, "lutaml/lml/has_attributes"
     autoload :VERSION, "lutaml/lml/version"
 
+    # Type classes (Lutaml::Model::Type::Value subclasses, not models)
+    autoload :LiteralValue, "lutaml/lml/literal_value"
+
     # Model classes (in Lutaml::Lml namespace, files in models/ directory)
     autoload :Action, "lutaml/lml/models/action"
     autoload :Association, "lutaml/lml/models/association"
@@ -64,5 +84,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