lutaml-lml 0.1.8 → 0.2.0

data/lib/lutaml/lml/preprocessor.rb

@@ -21,16 +21,19 @@ 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.
       def expand_lines(text, base_dir, chain)
+        text = strip_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)
 
@@ -45,13 +48,86 @@ module Lutaml
       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{//.*}, "")
+      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
+          end
+        end
+
+        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
       end
     end
   end

data/lib/lutaml/lml/validator.rb

@@ -0,0 +1,276 @@
+# 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
+
+      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
+        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"
+          )
+        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) +
+            reference_violations(instance)
+        end.compact
+      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 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)]
+        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 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]
+
+          [name, literal[:reference]]
+        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.0"
   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"
@@ -84,6 +85,9 @@ module Lutaml
     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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.2.0
 platform: ruby
 authors:
 - Ribose Inc.
@@ -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
@@ -133,11 +134,14 @@ 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/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 +155,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