lutaml-lml 0.2.0 → 0.2.1

data/lib/lutaml/lml/layout/elk_svg_markers.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    # SVG arrow-marker vocabulary and the <defs> block for ElkSvgRenderer.
+    # Marker ids are keyed by association member_end_type.
+    module ElkSvgMarkers
+      EDGE_STROKE = '#666666'
+
+      ARROW_MARKERS = {
+        'association' => 'arrow',
+        'aggregation' => 'diamond',
+        'composition' => 'diamond_filled',
+        'generalization' => 'triangle',
+        'uses' => 'arrow',
+        'direct' => 'arrow'
+      }.freeze
+
+      MARKER_SHAPES = {
+        'arrow' => %(<path d="M 0 0 L 10 5 L 0 10 z" fill="#{EDGE_STROKE}"/>),
+        'triangle' => %(<path d="M 0 0 L 12 5 L 0 10 z" fill="white" stroke="#{EDGE_STROKE}"/>),
+        'diamond' => %(<path d="M 0 4 L 7 0 L 14 4 L 7 8 z" fill="white" stroke="#{EDGE_STROKE}"/>),
+        'diamond_filled' => %(<path d="M 0 4 L 7 0 L 14 4 L 7 8 z" fill="#{EDGE_STROKE}"/>)
+      }.freeze
+
+      def arrow_marker(edge)
+        edge_type = edge.properties&.fetch('member_end_type', nil)
+        ARROW_MARKERS.fetch(edge_type.to_s, 'arrow')
+      end
+
+      def defs
+        MARKER_SHAPES.filter_map { |id, path| marker_def(id, path) }.join("\n")
+      end
+
+      private
+
+      def marker_def(id, path)
+        w, h = id.start_with?('diamond') ? %w[14 8] : %w[10 10]
+        %(<marker id="#{id}" viewBox="0 0 #{w} #{h}" refX="9" refY="4" ) +
+          %(markerWidth="#{w}" markerHeight="#{h}" ) +
+          %(orient="auto-start-reverse">#{path}</marker>)
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout/elk_svg_renderer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Layout
+    # Renders a laid-out Elkrb::Graph (nodes positioned by the layout) as
+    # standalone SVG: rounded-rect nodes with text-line labels and
+    # polyline edges with per-type arrow markers.
+    class ElkSvgRenderer
+      include ElkSvgMarkers
+
+      EDGE_STROKE = ElkSvgMarkers::EDGE_STROKE
+
+      HEADER = <<~XML
+        <?xml version="1.0" encoding="UTF-8"?>
+        <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="%<width>s" height="%<height>s" viewBox="0 0 %<width>s %<height>s">
+      XML
+      NODE_FILL = '#f8f8f8'
+      NODE_STROKE = '#333333'
+
+      def render(graph)
+        @graph = graph
+        @out = +''
+        @out << format(HEADER, width: bounds_width, height: bounds_height)
+        @out << "<defs>\n#{defs}\n</defs>\n"
+        nodes
+        edges
+        @out << "</svg>\n"
+        @out
+      end
+
+      private
+
+      def nodes
+        @graph.children.each { |node| render_node(node) }
+      end
+
+      def render_node(node)
+        @out << %(<g transform="translate(#{node.x.to_i},#{node.y.to_i})">)
+        @out << node_rect(node)
+        node.labels.each_with_index { |label, i| @out << node_label(label, i) }
+        @out << '</g>'
+      end
+
+      def node_rect(node)
+        %(<rect width="#{node.width.to_i}" height="#{node.height.to_i}" rx="6" ) +
+          %(fill="#{NODE_FILL}" stroke="#{NODE_STROKE}"/>)
+      end
+
+      def node_label(label, index)
+        y = ((index + 0.7) * ElkGraphBuilder::LINE_HEIGHT).round(1)
+        weight = index.zero? ? ' font-weight="bold"' : ''
+        %(<text x="7" y="#{y}" font-family="Helvetica" font-size="12"#{weight}>#{escape(label.text)}</text>)
+      end
+
+      def edges
+        @graph.edges.each { |edge| render_edge(edge) }
+      end
+
+      def render_edge(edge)
+        points = edge_points(edge)
+        return if points.empty?
+
+        @out << edge_polyline(edge, points)
+        edge_label(edge, points)
+      end
+
+      def edge_polyline(edge, points)
+        pts = points.map { |p| "#{p.x.round(1)},#{p.y.round(1)}" }.join(' ')
+        %(<polyline fill="none" stroke="#{EDGE_STROKE}" marker-end="url(##{arrow_marker(edge)})" points="#{pts}"/>)
+      end
+
+      def edge_label(edge, points)
+        label = Array(edge.labels).first
+        return unless label&.text
+
+        @out << edge_label_text(label, edge_anchor(points))
+      end
+
+      def edge_anchor(points)
+        mid = points[points.size / 2]
+        { x: (mid.x + 4).round(1), y: (mid.y - 4).round(1) }
+      end
+
+      def edge_label_text(label, anchor)
+        %(<text x="#{anchor[:x]}" y="#{anchor[:y]}" font-family="Helvetica" ) +
+          %(font-size="10" fill="#{EDGE_STROKE}">#{escape(label.text)}</text>)
+      end
+
+      def edge_points(edge)
+        sections = Array(edge.sections)
+        return [] if sections.empty?
+
+        points = [sections.first.start_point]
+        sections.each do |section|
+          points.concat(Array(section.bend_points))
+          points << section.end_point
+        end
+        points.compact
+      end
+
+      def bounds_width
+        extent(:x, :width) + 20
+      end
+
+      def bounds_height
+        extent(:y, :height) + 20
+      end
+
+      def extent(pos, size)
+        values = @graph.children.map { |n| n.public_send(pos).to_f + n.public_send(size).to_f }
+        [values.max || 0, 0].max.round
+      end
+
+      def escape(text)
+        text.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+      end
+    end
+  end
+end

data/lib/lutaml/lml/layout/graph_viz_engine.rb

@@ -7,7 +7,7 @@ module Lutaml
   module Layout
     class GraphVizEngine < Engine
       def render(type)
-        Open3.popen3("dot -T#{type}") do |stdin, stdout, _stderr, _wait|
+        Open3.popen3("dot", "-T#{type}") do |stdin, stdout, _stderr, _wait|
           stdout.binmode
           stdin.puts(input)
           stdin.close

data/lib/lutaml/lml/layout.rb

@@ -4,5 +4,9 @@ module Lutaml
   module Layout
     autoload :Engine, "lutaml/lml/layout/engine"
     autoload :GraphVizEngine, "lutaml/lml/layout/graph_viz_engine"
+    autoload :ElkEngine, "lutaml/lml/layout/elk_engine"
+    autoload :ElkGraphBuilder, "lutaml/lml/layout/elk_graph_builder"
+    autoload :ElkSvgRenderer, "lutaml/lml/layout/elk_svg_renderer"
+    autoload :ElkSvgMarkers, "lutaml/lml/layout/elk_svg_markers"
   end
 end

data/lib/lutaml/lml/model_compiler.rb

@@ -145,6 +145,20 @@ module Lutaml
         klass.new(**attrs)
       end
 
+      # An inline map's cargo is {key_value_map: [{key:, value:}, ...]} with
+      # literal-shaped keys/values ({string: ..}, {number: ..}, {boolean: ..});
+      # materialize it as a plain Hash (issue #17: maps hydrate as data).
+      def hydrate_map_cargo(cargo)
+        cargo[:key_value_map].to_h do |pair|
+          [hydrate_scalar(pair[:key]).to_s, hydrate_scalar(pair[:value])]
+        end
+      end
+
+      def hydrate_scalar(literal)
+        literal = literal.value if literal.respond_to?(:value)
+        literal.is_a?(Hash) ? literal.values.first : literal
+      end
+
       def resolve_instance_type(instance)
         # L6: the explicit isa keyword is the type override; a `type`
         # attribute is ordinary data (pubid's identifier-kind field)
@@ -178,7 +192,14 @@ module Lutaml
       end
 
       def resolve_instance_value(value, nested, attr_def = nil)
+        value = value.value if value.respond_to?(:value)
+        return hydrate_map_cargo(value) if value.is_a?(Hash) && value.key?(:key_value_map)
+
         if nested.any?
+          # A scalar attribute with a single nested instance hydrates to
+          # the object itself; the declaration is the truth (issue #17).
+          return hydrate_instance(nested.first) if !attr_def&.collection && nested.one?
+
           nested.map { |i| hydrate_instance(i) }
         elsif value.is_a?(Array)
           value
@@ -337,7 +358,7 @@ module Lutaml
         return if attr_names.empty?
 
         klass.xml do |mapping|
-          mapping.root(root_name)
+          mapping.element(root_name)
           attr_names.each do |attr_name|
             mapping.map_element(attr_name.to_s, to: attr_name)
           end
@@ -371,7 +392,7 @@ module Lutaml
         rule_ns = mapping.rules.select { |r| r.kind == 'namespace' }
                                .to_h { |r| [r.field, namespace_class_for(r.field)] }
         klass.xml do |m|
-          m.root(mapping.element_name) if mapping.element_name
+          m.element(mapping.element_name) if mapping.element_name
           m.namespace(ns_class) if ns_class
           m.mixed_content if mapping.mixed_content
           mapping.rules.each do |rule|
@@ -421,7 +442,7 @@ module Lutaml
       def namespace_class_for(ref)
         return nil if ref.nil?
 
-        require "lutaml/xml/namespace" unless defined?(Lutaml::Xml::Namespace)
+        require 'lutaml/xml/namespace' unless defined?(Lutaml::Xml::Namespace)
 
         ns_class = @namespace_classes[ref]
         return ns_class if ns_class

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

@@ -17,6 +17,9 @@ module Lutaml
       attribute :enums, "Lutaml::Lml::Enum", collection: true, default: -> { [] }
       attribute :packages, "Lutaml::Lml::Package", collection: true, default: -> { [] }
       attribute :namespaces, "Lutaml::Lml::Namespace", collection: true, default: -> { [] }
+      # `models <Name> version "x.y.z"` headers: model name -> declared
+      # version (issue #16, the co-release identity line).
+      attribute :model_versions, :hash, default: -> { {} }
       attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
       attribute :primitives, "Lutaml::Lml::PrimitiveType", collection: true, default: -> { [] }
       attribute :associations, "Lutaml::Lml::Association", collection: true, default: -> { [] }
@@ -27,6 +30,32 @@ module Lutaml
       attribute :instance, "Lutaml::Lml::Instance"
       attribute :requires, :string, collection: true, default: -> { [] }
       attribute :instances, "Lutaml::Lml::InstanceCollection"
+
+      # Repeated `instances` blocks accumulate (issue #17): instances,
+      # imports, exports and collections concat; a duplicate collection
+      # name is an error (same name is a mistake, distinct names intent).
+      def instances=(collection)
+        collection = Lutaml::Lml::InstanceCollection.new(**collection) if collection.is_a?(Hash)
+        if @instances.nil? || (@instances.instances.empty? && @instances.imports.empty? &&
+            @instances.exports.empty? && @instances.collections.empty?)
+          @instances = collection
+        else
+          merge_instances(collection)
+        end
+      end
+
+      def merge_instances(incoming)
+        names = @instances.collections.map(&:name)
+        incoming.collections.each do |collection|
+          if names.include?(collection.name)
+            raise Lutaml::Lml::Error, "duplicate collection name '#{collection.name}'"
+          end
+        end
+        @instances.instances.concat(incoming.instances)
+        @instances.imports.concat(incoming.imports)
+        @instances.exports.concat(incoming.exports)
+        @instances.collections.concat(incoming.collections)
+      end
       attribute :view_imports, "Lutaml::Lml::ViewImport", collection: true, default: -> { [] }
       attribute :show_filter, "Lutaml::Lml::ViewFilter"
       attribute :hide_filter, "Lutaml::Lml::ViewFilter"

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,7 +8,7 @@ module Lutaml
       VISIBILITY_MAP = {
         '-' => 'private',
         '#' => 'protected',
-        '~' => 'friendly'
+        '~' => 'package'
       }.freeze
 
       rule(visibility_modifier: simple(:visibility_value)) do

data/lib/lutaml/lml/validator.rb

@@ -34,6 +34,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 +81,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 +117,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 +184,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 +272,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.2.1"
   end
 end