lutaml-lml 0.2.0 → 0.3.0

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

@@ -6,6 +6,7 @@ module Lutaml
       attribute :name, :string
       attribute :type, :string
       attribute :direction, :string, default: "in"
+      attribute :default, :string
     end
   end
 end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3001 par. Value type: a reference to another instance
+    # (`reference:(path)` / `ref:(path)`). The attribute's value slot keeps
+    # its primitive wire shape (a `reference` hash); this is the typed
+    # domain view of it, built at one canonical point
+    # (TopElementAttribute#reference) so validation and serialization
+    # consume structured references instead of re-sniffing hashes.
+    class Reference < Lutaml::Model::Serializable
+      attribute :path, :string
+
+      def segments
+        @segments ||= path.to_s.split('.')
+      end
+
+      def to_s
+        path.to_s
+      end
+    end
+  end
+end

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

@@ -83,6 +83,18 @@ module Lutaml
         model.value = value
       end
 
+      # RS 3001 par. Value type: the typed view of a reference value
+      # (`reference:(...)` / `ref:(...)`). Nil for every other value shape;
+      # for a list of references, the first reference.
+      def reference
+        literal = value.respond_to?(:value) ? value.value : value
+        cargo = literal.is_a?(::Array) ? literal.first : literal
+        cargo = cargo.value if cargo.is_a?(LiteralValue)
+        return nil unless cargo.is_a?(::Hash) && cargo[:reference]
+
+        Reference.new(path: cargo[:reference].to_s)
+      end
+
       private
 
       # A LiteralValue sits at the top level for a map literal, and inside the

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

@@ -20,7 +20,7 @@ module Lutaml
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true
       attribute :modifier, :string
       attribute :constraints, "Lutaml::Lml::Constraint", collection: true
-      attribute :operations, "Lutaml::Lml::Operation", collection: true
+      attribute :operations, "Lutaml::Lml::Operation", collection: true, default: -> { [] }
       attribute :data_types, "Lutaml::Lml::DataType", collection: true
       attribute :associations, "Lutaml::Lml::Association", collection: true
       attribute :wire_mappings, "Lutaml::Lml::Mapping", collection: true, default: -> { [] }

data/lib/lutaml/lml/preprocessor.rb

@@ -21,11 +21,12 @@ module Lutaml
 
       private
 
-      # RS 3001 §Comment: `//` to end of line and `/* ... */` block
-      # comments are stripped quote-aware before include expansion, so
-      # string literals (e.g. URLs) survive intact.
+      # Comments (`//`, `/* */`) are consumed by the grammar's trivia
+      # skip (parsanol-ruby#134); only include directives are expanded
+      # here. Line structure is preserved so parse-error positions
+      # match the source.
       def expand_lines(text, base_dir, chain)
-        text = strip_comments(text)
+        validate_block_comments(text)
         text.split(/\r?\n/)
             .flat_map { |line| expand_line(line, base_dir, chain) }
             .join("\n")
@@ -41,93 +42,57 @@ module Lutaml
       end
 
       def include_path(line, base_dir)
-        match = line.match(/^\s*include\s+(.+)/)
+        match = line.match(/^\s*include\s+(.+)$/)
         return nil unless match
 
-        File.expand_path(match[1].strip, base_dir)
+        File.expand_path(trim_trailing_comment(match[1].strip), base_dir)
+      end
+
+      def trim_trailing_comment(path)
+        path.sub(%r{\s+(//|/\*).*}, '')
       end
 
       def read_included(path)
-        File.read(path, encoding: "UTF-8")
+        File.read(path, encoding: 'UTF-8')
       rescue Errno::ENOENT, Errno::EACCES => e
         raise Error, "cannot read include #{path}: #{e.message}"
       end
 
-      def strip_comments(text)
-        scanner = CommentScanner.new(text)
-        out = +""
-        until scanner.done?
-          scanner.emit(out)
-        end
-        out
-      end
-
-      # Quote-aware scanner removing `//` and `/* */` comments while
-      # preserving string literals and line structure.
-      class CommentScanner
-        def initialize(text)
-          @text = text
-          @pos = 0
-          @quote = nil
-        end
-
-        def done?
-          @pos >= @text.length
-        end
-
-        def emit(out)
-          return emit_quoted(out) if @quote
-          return emit_delimiter(out) if string_delimiter?(@text[@pos])
-          return emit_block_comment(out) if block_comment_start?
-          return skip_line_comment if line_comment_start?
-
-          out << @text[@pos]
-          @pos += 1
-        end
-
-        private
-
-        def string_delimiter?(ch)
-          ch == '"' || ch == "'"
-        end
-
-        def emit_delimiter(out)
-          @quote = @text[@pos]
-          out << @text[@pos]
-          @pos += 1
-        end
-
-        def emit_quoted(out)
-          ch = @text[@pos]
-          out << ch
-          if ch == "\\"
-            out << @text[@pos + 1].to_s
-            @pos += 2
-          else
-            @quote = nil if ch == @quote
-            @pos += 1
+      # Quote-aware scan: a `/*` opened outside a string literal or a
+      # line comment must close before end of input. The grammar's
+      # trivia would otherwise reject the text with an unrelated
+      # expected-token error.
+      def validate_block_comments(text)
+        quote = nil
+        pos = 0
+        open_index = nil
+        while pos < text.length
+          ch = text[pos]
+          if quote
+            if ch == '\\'
+              pos += 2
+              next
+            end
+            quote = nil if ch == quote
+          elsif open_index
+            if text[pos, 2] == '*/'
+              open_index = nil
+              pos += 1
+            end
+          elsif ['"', "'"].include?(ch)
+            quote = ch
+          elsif text[pos, 2] == '//'
+            pos = text.index("\n", pos) || text.length
+            next
+          elsif text[pos, 2] == '/*'
+            open_index = pos
           end
+          pos += 1
         end
+        return unless open_index
 
-        def block_comment_start?
-          @text[@pos, 2] == "/*"
-        end
-
-        def emit_block_comment(out)
-          close = @text.index("*/", @pos + 2)
-          raise Lutaml::Lml::Error, "unterminated block comment" unless close
-
-          out << "\n" * @text[@pos...close].count("\n") << " "
-          @pos = close + 2
-        end
-
-        def line_comment_start?
-          @text[@pos, 2] == "//"
-        end
-
-        def skip_line_comment
-          @pos = @text.index("\n", @pos) || @text.length
-        end
+        line = text[0...open_index].count("\n") + 1
+        raise Error, "unterminated block comment at line #{line}"
       end
     end
   end

data/lib/lutaml/lml/transform.rb

@@ -8,17 +8,65 @@ module Lutaml
       VISIBILITY_MAP = {
         '-' => 'private',
         '#' => 'protected',
-        '~' => 'friendly'
+        '~' => 'package'
       }.freeze
 
       rule(visibility_modifier: simple(:visibility_value)) do
         VISIBILITY_MAP.fetch(visibility_value.to_s, 'public')
       end
-      # Global scalar normalizer: applied 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 }
+      # An empty `until` capture is an empty sequence, not an empty
+      # string: `""` parses the dq_string body as [] (parsanol
+      # repetition semantics). A present, zero-length string value is
+      # distinct from an absent one (RS 3001 §String values); only the
+      # :string capture is normalized, other empty sequences stay [].
+      rule(string: sequence(:empty_string)) { { string: '' } }
+
+      # RS 3001 §String values: the only two escapes are backslash-quote
+      # and backslash-backslash (the grammar rejects every other
+      # backslash), so unescaping is removing the backslash before
+      # those two characters.
+      rule(string: simple(:escaped)) { { string: Lutaml::Lml::Transform.unescape(escaped.to_s) } }
+
+      # Rule blocks evaluate in a Parsanol::Context, so this helper is
+      # a class method the block reaches through the class.
+      # @param body [String] raw string body as captured between quotes
+      # @return [String] the value with \" and \\ resolved
+      def self.unescape(body)
+        body.gsub(/\\(["'\\])/) { Regexp.last_match(1) }
+      end
+
+      # Global scalar normalizer: every leaf becomes a string (or stays
+      # nil). No stripping — name and type tokens are interior-bounded
+      # in the grammar (class_run/type_run/quoted_name_run), so quoted
+      # string values keep their padding verbatim (RS 3001 §String
+      # values).
+      rule(simple(:value)) { value.nil? ? value : value.to_s }
+
+      # Block captures (definition bodies, block comments) read their
+      # surrounding layout as content — a block's first line break and
+      # closing indentation are layout, not prose. parsanol only fires
+      # hash-keyed rules at selected tree positions, so the strip is a
+      # post-pass walk, not a rule.
+      BLOCK_KEYS = %i[definition comments].freeze
+
+      def apply(tree, context = nil)
+        strip_block_layout(super)
+      end
+
+      def strip_block_layout(node)
+        case node
+        when Hash
+          node.each_with_object({}) do |(key, value), result|
+            result[key] = if BLOCK_KEYS.include?(key) && value.is_a?(String)
+                            value.strip
+                          else
+                            strip_block_layout(value)
+                          end
+          end
+        when Array then node.map { |item| strip_block_layout(item) }
+        else node
+        end
+      end
     end
   end
 end

data/lib/lutaml/lml/validator.rb

@@ -14,7 +14,8 @@ module Lutaml
         'Integer' => /\A-?\d+\z/,
         'Number' => /\A-?\d+\z/,
         'Float' => /\A-?\d+\.\d+\z/,
-        'Boolean' => /\A(true|false)\z/
+        'Boolean' => /\A(true|false)\z/,
+        'Null' => /\Anull\z/
       }.freeze
 
       COLLECTION_KEYS = %i[properties attributes instances].freeze
@@ -34,6 +35,28 @@ module Lutaml
           circular_reference_violations
       end
 
+      # RS 3001 scopes definitions to packages: uniqueness is per scope
+      # (the document root and each package, recursively), not global.
+      def definition_scopes
+        scopes = [[nil, document_definitions]]
+        Array(@document.packages).each { |pkg| collect_package_scopes(pkg, scopes) }
+        scopes
+      end
+
+      def document_definitions
+        [
+          *Array(@document.classes),
+          *Array(@document.enums),
+          *Array(@document.data_types)
+        ]
+      end
+
+      def collect_package_scopes(pkg, scopes, parent = nil)
+        path = parent ? "#{parent}.#{pkg.name}" : pkg.name.to_s
+        scopes << [path, [*Array(pkg.classes), *Array(pkg.enums), *Array(pkg.data_types)]]
+        Array(pkg.packages).each { |nested| collect_package_scopes(nested, scopes, path) }
+      end
+
       private
 
       def all_definitions
@@ -59,14 +82,18 @@ module Lutaml
       end
 
       def unique_name_violations
-        names = all_definitions.map(&:first)
-        names.tally.filter_map do |name, count|
-          next if count == 1
-
-          Violation.new(
-            rule: 'unique_names',
-            message: "'#{name}' is defined #{count} times"
-          )
+        definition_scopes.flat_map do |scope, definitions|
+          scope_label = scope ? "package '#{scope}'" : 'the document root'
+          definitions.map { |d| d.name.to_s }
+                     .tally
+                     .filter_map do |name, count|
+            next if count == 1
+
+            Violation.new(
+              rule: 'unique_names',
+              message: "'#{name}' is defined #{count} times in #{scope_label}"
+            )
+          end
         end
       end
 
@@ -91,10 +118,49 @@ module Lutaml
         instances.flat_map do |instance|
           mandatory_violations(instance) +
             type_conformity_violations(instance) +
+            values_set_violations(instance) +
+            unknown_attribute_violations(instance) +
             reference_violations(instance)
         end.compact
       end
 
+      # RS 3001 par. Attribute: a `values` declaration restricts an
+      # attribute to its declared set.
+      def values_set_violations(instance)
+        definition = type_definitions[definition_type(instance)]
+        return [] unless definition.is_a?(UmlClass) || definition.is_a?(DataType)
+
+        instance_attribute_pairs(instance).filter_map do |name, value|
+          attr = Array(definition.attributes).find { |a| a.name.to_s == name }
+          next unless attr && !attr.value_set.empty?
+
+          literal = value.respond_to?(:value) ? value.value : value
+          next if attr.value_set.map(&:to_s).include?(literal.to_s)
+
+          Violation.new(
+            rule: 'values_set_membership',
+            message: "instance '#{instance_name(instance)}': attribute '#{name}' " \
+                     "must be one of #{attr.value_set.inspect}, got #{literal.to_s.inspect}"
+          )
+        end
+      end
+
+      def unknown_attribute_violations(instance)
+        definition = type_definitions[definition_type(instance)]
+        return [] unless definition.is_a?(UmlClass) || definition.is_a?(DataType)
+
+        declared = attribute_names(definition)
+        instance_attribute_pairs(instance)
+          .reject { |name, _value| declared.include?(name) }
+          .map do |name, _value|
+            Violation.new(
+              rule: 'unknown_attributes',
+              message: "instance '#{instance_name(instance)}' (#{definition_type(instance)}): " \
+                       "unknown attribute '#{name}'"
+            )
+          end
+      end
+
       def instances
         Array(@document.instances&.instances)
       end
@@ -119,13 +185,7 @@ module Lutaml
         attr.cardinality && attr.cardinality.min == '1'
       end
 
-      def populated?(instance, attr_name)
-        pair = instance_attribute(instance, attr_name)
-        return false unless pair
 
-        value = pair[1]
-        value.respond_to?(:value) ? !value.to_s.empty? : !value.to_s.empty?
-      end
 
       def type_conformity_violations(instance)
         definition = type_definitions[definition_type(instance)]
@@ -213,12 +273,21 @@ module Lutaml
         literal
       end
 
+      def populated?(instance, attr_name)
+        pair = instance_attribute(instance, attr_name)
+        return false unless pair
+
+        value = pair[1]
+        literal = value.respond_to?(:value) ? value.value : value
+        !literal.to_s.empty?
+      end
+
       def reference_values(instance)
-        instance_attribute_pairs(instance).filter_map do |name, value|
-          literal = value.respond_to?(:value) ? value.value : value
-          next unless literal.is_a?(Hash) && literal[:reference]
+        Array(instance.attributes).filter_map do |attr|
+          ref = attr.reference
+          next unless ref
 
-          [name, literal[:reference]]
+          [attr.name.to_s, ref.path]
         end
       end
 

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.2.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/lutaml/lml.rb

@@ -2,6 +2,7 @@
 
 require "lutaml/model"
 
+# Root namespace for the LutaML libraries.
 module Lutaml
   class Error < StandardError; end
 
@@ -11,6 +12,10 @@ module Lutaml
   autoload :Formatter, "lutaml/lml/formatter"
   autoload :Layout, "lutaml/lml/layout"
 
+  # LML — the LutaML Model Language: parses the text DSL into domain
+  # documents, compiles model definitions into Serializable classes,
+  # and renders diagrams. See the entry-point contract under .parse /
+  # .parse_document below.
   module Lml
     class Error < Lutaml::Error; end
     class ParsingError < Error; end
@@ -20,15 +25,25 @@ module Lutaml
       ModelCompiler.new(namespace: namespace).compile(input)
     end
 
-    # Full entry point: parse, then resolve view imports and enrich
-    # association labels.
+    # Entry-point contract:
+    #
+    #   parse           — Pipeline (preprocess, parse, transform, build)
+    #                     followed by ViewResolution: view-import
+    #                     expansion, show/hide filtering, and
+    #                     association-label enrichment. Use for
+    #                     documents consumed as diagrams or views.
+    #   parse_document  — Pipeline only; the document keeps raw
+    #                     collections and unresolved imports. Use for
+    #                     machine processing (ModelCompiler, Validator)
+    #                     where view semantics do not apply.
+    #
+    # Both return a Lutaml::Lml::Document.
     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
@@ -80,6 +95,7 @@ module Lutaml
     autoload :OperationParameter, "lutaml/lml/models/operation_parameter"
     autoload :Package, "lutaml/lml/models/package"
     autoload :PrimitiveType, "lutaml/lml/models/primitive_type"
+    autoload :Reference, "lutaml/lml/models/reference"
     autoload :TopElementAttribute, "lutaml/lml/models/top_element_attribute"
     autoload :UmlClass, "lutaml/lml/models/uml_class"
     autoload :Value, "lutaml/lml/models/value"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.57
+        version: 1.3.68
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.57
+        version: 1.3.68
 - !ruby/object:Gem::Dependency
   name: moxml
   requirement: !ruby/object:Gem::Requirement
@@ -102,21 +102,33 @@ files:
 - lib/lutaml/lml/format/adapter/transform.rb
 - lib/lutaml/lml/formatter.rb
 - lib/lutaml/lml/formatter/base.rb
+- lib/lutaml/lml/formatter/elk.rb
 - lib/lutaml/lml/formatter/graphviz.rb
 - lib/lutaml/lml/formatter/graphviz/document_formatter.rb
 - lib/lutaml/lml/formatter/graphviz/html_builder.rb
 - lib/lutaml/lml/formatter/graphviz/node_formatter.rb
 - lib/lutaml/lml/formatter/graphviz/relationship_formatter.rb
+- lib/lutaml/lml/formatter/svg_pdf.rb
+- lib/lutaml/lml/formatter/svg_pdf/path_parser.rb
 - lib/lutaml/lml/grammar.rb
 - lib/lutaml/lml/grammar/lml.artifact.json
 - lib/lutaml/lml/grammar/lml.parg
 - lib/lutaml/lml/has_attributes.rb
 - lib/lutaml/lml/import_resolver.rb
 - lib/lutaml/lml/layout.rb
+- lib/lutaml/lml/layout/elk_engine.rb
+- lib/lutaml/lml/layout/elk_graph_builder.rb
+- lib/lutaml/lml/layout/elk_svg_markers.rb
+- lib/lutaml/lml/layout/elk_svg_renderer.rb
 - lib/lutaml/lml/layout/engine.rb
 - lib/lutaml/lml/layout/graph_viz_engine.rb
 - lib/lutaml/lml/literal_value.rb
 - lib/lutaml/lml/model_compiler.rb
+- lib/lutaml/lml/model_compiler/enums.rb
+- lib/lutaml/lml/model_compiler/hydration.rb
+- lib/lutaml/lml/model_compiler/serialization_mappings.rb
+- lib/lutaml/lml/model_compiler/string_formats.rb
+- lib/lutaml/lml/model_compiler/validation.rb
 - lib/lutaml/lml/models/action.rb
 - lib/lutaml/lml/models/association.rb
 - lib/lutaml/lml/models/cardinality.rb
@@ -141,6 +153,7 @@ files:
 - lib/lutaml/lml/models/operation_parameter.rb
 - lib/lutaml/lml/models/package.rb
 - lib/lutaml/lml/models/primitive_type.rb
+- lib/lutaml/lml/models/reference.rb
 - lib/lutaml/lml/models/serialization_mapping.rb
 - lib/lutaml/lml/models/string_format.rb
 - lib/lutaml/lml/models/top_element_attribute.rb