lutaml-lml 0.1.8 → 0.2.1

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

@@ -19,6 +19,8 @@ module Lutaml
       attribute :definition, Lutaml::Lml::Types::TextType
       attribute :association, :string
       attribute :default, :string
+      attribute :value_set, :string, collection: true, default: -> { [] }
+      attribute :pattern, :string
 
       # LML-specific attributes
       attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
@@ -53,6 +55,8 @@ module Lutaml
         map "definition", to: :definition
         map "association", to: :association
         map "default", to: :default
+        map "value_set", to: :value_set
+        map "pattern", to: :pattern
         map "properties", to: :properties
         map "value", to: :value, with: { to: :value_to, from: :value_from }
         map "attributes", to: :attributes
@@ -79,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,12 +20,13 @@ 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: -> { [] }
       attribute :string_formats, "Lutaml::Lml::StringFormat", collection: true, default: -> { [] }
       attribute :derived_fields, "Lutaml::Lml::DerivedField", collection: true, default: -> { [] }
+      attribute :serialization_mappings, "Lutaml::Lml::SerializationMapping", collection: true, default: -> { [] }
 
       # LML-specific
       attribute :parent_class, :string

data/lib/lutaml/lml/preprocessor.rb

@@ -21,16 +21,20 @@ module Lutaml
 
       private
 
+      # 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)
+        validate_block_comments(text)
         text.split(/\r?\n/)
             .flat_map { |line| expand_line(line, base_dir, chain) }
             .join("\n")
       end
 
       def expand_line(line, base_dir, chain)
-        cleaned = strip_comment(line)
-        path = include_path(cleaned, base_dir)
-        return [cleaned] unless path
+        path = include_path(line, base_dir)
+        return [line] unless path
 
         raise Error, "circular include detected: #{path}" if chain.include?(path)
 
@@ -38,20 +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)
+        File.read(path, encoding: 'UTF-8')
       rescue Errno::ENOENT, Errno::EACCES => e
         raise Error, "cannot read include #{path}: #{e.message}"
       end
 
-      def strip_comment(line)
-        line.sub(%r{//.*}, "")
+      # 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
+
+        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

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Lml
+    # RS 3001 §Validation rules evaluated over a parsed document:
+    # class constraints (unique names, unique attribute names), attribute
+    # constraints (mandatory cardinality-1 attributes populated, values
+    # matching declared types) and reference validity (ref: paths resolve
+    # to instances and are acyclic).
+    class Validator
+      Violation = Struct.new(:rule, :message, keyword_init: true)
+
+      PRIMITIVE_CONFORMITY = {
+        'Integer' => /\A-?\d+\z/,
+        'Number' => /\A-?\d+\z/,
+        'Float' => /\A-?\d+\.\d+\z/,
+        'Boolean' => /\A(true|false)\z/
+      }.freeze
+
+      COLLECTION_KEYS = %i[properties attributes instances].freeze
+
+      def self.violations(document)
+        new(document).violations
+      end
+
+      def initialize(document)
+        @document = document
+      end
+
+      def violations
+        unique_name_violations +
+          unique_attribute_violations +
+          instance_violations +
+          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
+        @all_definitions ||= begin
+          pairs = []
+          Array(@document.classes).each { |c| pairs << [c.name.to_s, c] }
+          Array(@document.enums).each { |e| pairs << [e.name.to_s, e] }
+          Array(@document.data_types).each { |d| pairs << [d.name.to_s, d] }
+          Array(@document.packages).each { |pkg| collect_package_definitions(pkg, pairs) }
+          pairs
+        end
+      end
+
+      def collect_package_definitions(pkg, pairs)
+        Array(pkg.classes).each { |c| pairs << [c.name.to_s, c] }
+        Array(pkg.enums).each { |e| pairs << [e.name.to_s, e] }
+        Array(pkg.data_types).each { |d| pairs << [d.name.to_s, d] }
+        Array(pkg.packages).each { |nested| collect_package_definitions(nested, pairs) }
+      end
+
+      def type_definitions
+        @type_definitions ||= all_definitions.to_h
+      end
+
+      def unique_name_violations
+        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
+
+      def unique_attribute_violations
+        type_definitions.filter_map do |name, definition|
+          dupes = attribute_names(definition)
+                  .tally.select { |_attr, count| count > 1 }.keys
+          next if dupes.empty?
+
+          Violation.new(
+            rule: 'unique_attribute_names',
+            message: "#{name}: duplicate attribute(s) #{dupes.inspect}"
+          )
+        end
+      end
+
+      def attribute_names(definition)
+        Array(definition.attributes).map(&:name).map(&:to_s)
+      end
+
+      def instance_violations
+        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
+
+      def mandatory_violations(instance)
+        definition = type_definitions[definition_type(instance)]
+        return [] unless definition.is_a?(UmlClass) || definition.is_a?(DataType)
+
+        definition.attributes.filter_map do |attr|
+          next unless mandatory?(attr)
+          next if populated?(instance, attr.name.to_s)
+
+          Violation.new(
+            rule: 'mandatory_attributes',
+            message: "instance '#{instance_name(instance)}' (#{definition_type(instance)}): " \
+                     "mandatory attribute '#{attr.name}' is not populated"
+          )
+        end
+      end
+
+      def mandatory?(attr)
+        attr.cardinality && attr.cardinality.min == '1'
+      end
+
+
+
+      def type_conformity_violations(instance)
+        definition = type_definitions[definition_type(instance)]
+        return [] unless definition.respond_to?(:attributes)
+
+        instance_attribute_pairs(instance).filter_map do |name, value|
+          attr = Array(definition.attributes).find { |a| a.name.to_s == name }
+          next unless attr
+
+          conformity_violation(instance, name, attr, value)
+        end
+      end
+
+      def conformity_violation(instance, name, attr, value)
+        pattern = PRIMITIVE_CONFORMITY[attr.type.to_s]
+        return unless pattern
+        return if pattern.match?(value.to_s)
+
+        Violation.new(
+          rule: 'type_conformity',
+          message: "instance '#{instance_name(instance)}': attribute '#{name}' " \
+                   "expects #{attr.type}, got #{value.to_s.inspect}"
+        )
+      end
+
+      def reference_violations(instance)
+        reference_values(instance).filter_map do |name, path|
+          segments = path.to_s.split('.')
+          unless resolvable_reference?(segments)
+            next Violation.new(
+              rule: 'reference_validity',
+              message: "instance '#{instance_name(instance)}': attribute '#{name}' " \
+                       "references unknown path '#{path}'"
+            )
+          end
+
+          attribute_violation(instance, name, path, segments.first)
+        end
+      end
+
+      # RS 3001 reference paths: `instance` / `instance.attribute` /
+      # `collection.instance`.
+      def resolvable_reference?(segments)
+        case segments.length
+        when 1 then instance_names.include?(segments.first)
+        when 2 then instance_names.include?(segments.first) ||
+          collection_names.include?(segments.first)
+        else false
+        end
+      end
+
+      def collection_names
+        @collection_names ||= [@document.instances&.name].compact
+      end
+
+      def attribute_violation(instance, _name, path, target)
+        segment = path.to_s.split('.')[1]
+        target_instance = instances.find { |i| instance_name(i) == target }
+        return if segment.nil? || target_instance.nil? ||
+                  instance_attribute(target_instance, segment)
+
+        Violation.new(
+          rule: 'reference_validity',
+          message: "instance '#{instance_name(instance)}': reference '#{path}' " \
+                   "does not resolve (no attribute '#{segment}' on '#{target}')"
+        )
+      end
+
+      def instance_attribute_pairs(instance)
+        pairs = []
+        instance.each_attribute do |name, value, instances|
+          pairs << [name.to_s, value_for(value, instances)]
+        end
+        pairs
+      end
+
+      def instance_attribute(instance, attr_name)
+        instance_attribute_pairs(instance).find { |name, _value| name == attr_name }
+      end
+
+      def value_for(value, instances)
+        literal = value.respond_to?(:value) ? value.value : value
+        return instances.first if literal.is_a?(Hash) && literal[:instances]
+
+        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)
+        Array(instance.attributes).filter_map do |attr|
+          ref = attr.reference
+          next unless ref
+
+          [attr.name.to_s, ref.path]
+        end
+      end
+
+      def instance_names
+        @instance_names ||= instances.map { |i| instance_name(i) }
+      end
+
+      # RS 3001: circular references are invalid.
+      def circular_reference_violations
+        graph = instances.to_h do |instance|
+          targets = reference_values(instance)
+                    .map { |_name, path| path.to_s.split('.').first }
+          [instance_name(instance), targets]
+        end
+        cycles = cycles_in(graph)
+        cycles.map do |cycle|
+          Violation.new(
+            rule: 'reference_circularity',
+            message: "circular reference: #{cycle.join(' -> ')}"
+          )
+        end
+      end
+
+      def cycles_in(graph)
+        cycles = []
+        graph.each_key do |start|
+          path = walk_for_cycle(graph, start)
+          cycles << path if path
+        end
+        cycles.uniq { |cycle| cycle.sort }
+      end
+
+      def walk_for_cycle(graph, start)
+        path = [start]
+        node = start
+        loop do
+          nexts = graph[node] || []
+          node = nexts.first
+          return nil if node.nil? || node == '' || !graph.key?(node)
+          return path + [node] if path.include?(node)
+
+          path << node
+        end
+      end
+
+      def instance_name(instance)
+        instance.respond_to?(:name) ? instance.name.to_s : ''
+      end
+
+      def definition_type(instance)
+        (instance.isa || instance.type).to_s
+      end
+    end
+  end
+end

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.1.8"
+    VERSION = "0.2.1"
   end
 end

data/lib/lutaml/lml.rb

@@ -44,6 +44,7 @@ module Lutaml
     autoload :ModelCompiler, "lutaml/lml/model_compiler"
     autoload :ImportResolver, "lutaml/lml/import_resolver"
     autoload :ViewResolver, "lutaml/lml/view_resolver"
+    autoload :Validator, "lutaml/lml/validator"
     autoload :ViewResolution, "lutaml/lml/view_resolution"
     autoload :EntityTypes, "lutaml/lml/entity_types"
     autoload :AssociationLabelResolver, "lutaml/lml/association_label_resolver"
@@ -79,11 +80,15 @@ 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"
     autoload :ViewFilter, "lutaml/lml/models/view_filter"
     autoload :ViewImport, "lutaml/lml/models/view_import"
+    autoload :MappingRule, "lutaml/lml/models/mapping_rule"
+    autoload :Namespace, "lutaml/lml/models/namespace"
+    autoload :SerializationMapping, "lutaml/lml/models/serialization_mapping"
 
     # Namespaces with their own autoloads
     autoload :Grammar, "lutaml/lml/grammar"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-05 00:00:00.000000000 Z
+date: 2026-10-08 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
@@ -84,6 +84,7 @@ files:
 - lib/lutaml/lml/data_processor/attribute_processing.rb
 - lib/lutaml/lml/data_processor/collection_processing.rb
 - lib/lutaml/lml/data_processor/instance_processing.rb
+- lib/lutaml/lml/data_processor/value_declaration_processing.rb
 - lib/lutaml/lml/data_processor/value_processing.rb
 - lib/lutaml/lml/data_processor/view_processing.rb
 - lib/lutaml/lml/document_builder.rb
@@ -101,6 +102,7 @@ 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
@@ -112,6 +114,10 @@ files:
 - 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
@@ -133,11 +139,15 @@ files:
 - lib/lutaml/lml/models/instances_export.rb
 - lib/lutaml/lml/models/instances_import.rb
 - lib/lutaml/lml/models/mapping.rb
+- lib/lutaml/lml/models/mapping_rule.rb
 - lib/lutaml/lml/models/member_field.rb
+- lib/lutaml/lml/models/namespace.rb
 - lib/lutaml/lml/models/operation.rb
 - 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
 - lib/lutaml/lml/models/uml_class.rb
@@ -151,6 +161,7 @@ files:
 - lib/lutaml/lml/transform.rb
 - lib/lutaml/lml/types.rb
 - lib/lutaml/lml/types/text_type.rb
+- lib/lutaml/lml/validator.rb
 - lib/lutaml/lml/version.rb
 - lib/lutaml/lml/view_resolution.rb
 - lib/lutaml/lml/view_resolver.rb