lutaml-lml 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3953cc3c0f81db402cab373b0da574ebd8832e2aa42c98de6e88e3fc157e4503
-  data.tar.gz: d3816ea57a18d40ff1577757367f41fc604e54ad945545223820787dff81a86b
+  metadata.gz: 16aa3d91bcea83c3eec5b3ab8ae3d3c9b91386d39abf80da4da5704487d22edf
+  data.tar.gz: e1a1db496cd7888458915a831f874b16e72f6894b251740bc873aea17f6bf6b3
 SHA512:
-  metadata.gz: cd7dc48c1d8a1d89718e755e93ffc7a0ac0d577aab1d6c0986ddd7d45d6df3f88b1716f1514e445df0e3ab6c10b306904b3219247126bf5e60b8568acb6aafd3
-  data.tar.gz: 9c79221cf405d9512c094da610abdb7ab4f8675ce64ca7180c0039e337a281872483ef31db2f9344a0e7c853d1d51085e3108b08b1e6fba83bd200134da5aa2d
+  metadata.gz: f407f3ce4984f37f9b0a4c5932e99b4062439aceb6287a43e960f9166eeb0b3476a675981afd6777d453a1e895f09e576e0ea4b813cd42921712999bb8f38cca
+  data.tar.gz: 04705fa33b170b9966ef004a743100c4490c4dd954b43cb2cfe243badbaf6d3b898aea33b24dd980f14d2074bc4db83db2ddf2e4f64dae79bd4b911a84db8999

data/lib/lutaml/lml/executor.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "forwardable"
+
 module Lutaml
   module Lml
     # Orchestrates instance data I/O: import external data, validate
@@ -12,7 +14,9 @@ module Lutaml
     # Usage:
     #   compiled = ModelCompiler.new.compile(models_file)
     #   doc = Pipeline.call(instances_file, resolve: false)
-    #   instances = Executor.run(doc, compiled: compiled)
+    #   result = Executor.run(doc, compiled: compiled)
+    #   result.instances  # array of hydrated instance objects
+    #   result.errors     # array of validation error strings
     #
     class Executor
       autoload :FormatAdapter, "lutaml/lml/executor/format_adapter"
@@ -21,6 +25,16 @@ module Lutaml
       autoload :XmlAdapter, "lutaml/lml/executor/xml_adapter"
       autoload :ConditionEvaluator, "lutaml/lml/executor/condition_evaluator"
 
+      # Result of running the executor: hydrated instances plus any
+      # validation errors collected along the way. Delegates array-like
+      # methods to instances so existing callers that treated the run
+      # return value as an array continue to work.
+      Result = Struct.new(:instances, :errors) do
+        extend Forwardable
+
+        def_delegators :instances, :length, :each, :map, :[], :empty?
+      end
+
       attr_reader :compiled
 
       def initialize(compiled:)
@@ -28,16 +42,16 @@ module Lutaml
       end
 
       # Run the full import/validate/export cycle on a parsed document.
-      # Returns an array of hydrated instance objects.
+      # Returns a Result with hydrated instances and validation errors.
       def self.run(doc, compiled:)
         new(compiled: compiled).run(doc)
       end
 
       def run(doc)
         instances = run_imports(doc)
-        validate_collections(doc, instances)
+        errors = validate_collections(doc, instances)
         run_exports(doc, instances)
-        instances
+        Result.new(instances, errors)
       end
 
       private
@@ -51,19 +65,16 @@ module Lutaml
       end
 
       def import_one(imp)
-        adapter = FormatAdapter.resolve(imp.format_type)
-        adapter.import(imp, compiled: @compiled)
-      rescue FormatAdapter::AdapterNotFoundError
-        []
+        FormatAdapter.resolve(imp.format_type).import(imp, compiled: @compiled)
       end
 
       # --- Collection validation ---
 
       def validate_collections(doc, instances)
-        return unless doc.instances&.collections
+        return [] unless doc.instances&.collections
 
         collection = doc.instances.collections
-        return unless collection.is_a?(Collection)
+        return [] unless collection.is_a?(Collection)
 
         ConditionEvaluator.evaluate(collection, instances)
       end
@@ -79,10 +90,7 @@ module Lutaml
       end
 
       def export_one(exp, instances)
-        adapter = FormatAdapter.resolve(exp.format_type)
-        adapter.export(exp, instances, compiled: @compiled)
-      rescue FormatAdapter::AdapterNotFoundError
-        nil
+        FormatAdapter.resolve(exp.format_type).export(exp, instances, compiled: @compiled)
       end
     end
   end

data/lib/lutaml/lml/format/adapter/standard_adapter.rb

@@ -15,10 +15,6 @@ module Lutaml
             instance_to_hash(doc.instance)
           end
 
-          def initialize(attributes = {}, **options)
-            super
-          end
-
           def to_lml(_options = {})
             attrs = @attributes.dup
             type_name = attrs.delete(TYPE_KEY) || "Data"
@@ -34,14 +30,14 @@ module Lutaml
             hash = {}
             hash[TYPE_KEY] = instance.type if instance.type
 
-            Array(instance.attributes).each do |attr|
-              if attr.instances.any?
-                hashes = attr.instances.map { |i| instance_to_hash(i) }
-                hash[attr.name] = attr.instances.one? ? hashes.first : hashes
-              elsif attr.value.is_a?(Array)
-                hash[attr.name] = attr.value.map { |v| primitive_value(v) }
-              elsif !attr.value.nil?
-                hash[attr.name] = primitive_value(attr.value)
+            instance.each_attribute do |name, value, nested|
+              if nested.any?
+                hashes = nested.map { |i| instance_to_hash(i) }
+                hash[name] = nested.one? ? hashes.first : hashes
+              elsif value.is_a?(Array)
+                hash[name] = value.map { |v| primitive_value(v) }
+              elsif !value.nil?
+                hash[name] = primitive_value(value)
               end
             end
 

data/lib/lutaml/lml/formatter/base.rb

@@ -56,10 +56,7 @@ module Lutaml
       end
 
       def format(node)
-        result = dispatch_format(node)
-        return unless result
-
-        result
+        dispatch_format(node)
       end
 
       def dispatch_format(node)

data/lib/lutaml/lml/grammar/concerns/definitions.rb

@@ -7,6 +7,17 @@ module Lutaml
         module Definitions
           include Parslet
 
+          # Compose a brace-delimited body parser around an inner rule.
+          # All *_body rules share this scaffold; only the inner rule
+          # differs.
+          def braced_body(inner)
+            spaces? >>
+              str("{") >>
+              whitespace? >>
+              inner.repeat.as(:members) >>
+              str("}")
+          end
+
           # -- Class
           rule(:kw_class_modifier) { kw_abstract | kw_interface }
 
@@ -25,11 +36,7 @@ module Lutaml
             class_inner_definitions >> whitespace?
           end
           rule(:class_body) do
-            spaces? >>
-              str("{") >>
-              whitespace? >>
-              class_inner_definition.repeat.as(:members) >>
-              str("}")
+            braced_body(class_inner_definition)
           end
           rule(:class_body?) { class_body.maybe }
 
@@ -58,23 +65,19 @@ module Lutaml
               str("}")
           end
 
-          # -- Enum
+          # -- Enum and data_type share the same body content
           rule(:enum_keyword) { kw_enum >> spaces }
-          rule(:enum_inner_definitions) do
+          rule(:enum_or_data_type_inner_definitions) do
             definition_body |
               attribute_definition |
               comment_definition |
               comment_multiline_definition
           end
-          rule(:enum_inner_definition) do
-            enum_inner_definitions >> whitespace?
+          rule(:enum_or_data_type_inner_definition) do
+            enum_or_data_type_inner_definitions >> whitespace?
           end
           rule(:enum_body) do
-            spaces? >>
-              str("{") >>
-              whitespace? >>
-              enum_inner_definition.repeat.as(:members) >>
-              str("}")
+            braced_body(enum_or_data_type_inner_definition)
           end
           rule(:enum_body?) { enum_body.maybe }
           rule(:enum_definition) do
@@ -88,21 +91,8 @@ module Lutaml
 
           # -- data_type
           rule(:data_type_keyword) { kw_data_type >> spaces }
-          rule(:data_type_inner_definitions) do
-            definition_body |
-              attribute_definition |
-              comment_definition |
-              comment_multiline_definition
-          end
-          rule(:data_type_inner_definition) do
-            data_type_inner_definitions >> whitespace?
-          end
           rule(:data_type_body) do
-            spaces? >>
-              str("{") >>
-              whitespace? >>
-              data_type_inner_definition.repeat.as(:members) >>
-              str("}")
+            braced_body(enum_or_data_type_inner_definition)
           end
           rule(:data_type_body?) { data_type_body.maybe }
           rule(:data_type_definition) do
@@ -141,11 +131,7 @@ module Lutaml
             diagram_inner_definitions >> whitespace?
           end
           rule(:diagram_body) do
-            spaces? >>
-              str("{") >>
-              whitespace? >>
-              diagram_inner_definition.repeat.as(:members) >>
-              str("}")
+            braced_body(diagram_inner_definition)
           end
           rule(:diagram_definition) do
             diagram_keyword >>
@@ -177,11 +163,7 @@ module Lutaml
             view_inner_definitions >> whitespace?
           end
           rule(:view_body) do
-            spaces? >>
-              str("{") >>
-              whitespace? >>
-              view_inner_definition.repeat.as(:members) >>
-              str("}")
+            braced_body(view_inner_definition)
           end
           rule(:view_definition) do
             view_keyword >>

data/lib/lutaml/lml/model_compiler.rb

@@ -18,6 +18,10 @@ module Lutaml
         "Hash" => :hash,
       }.freeze
 
+      # Tokens that denote unbounded cardinality in LML attribute
+      # declarations. Anything else must parse as an Integer.
+      UNBOUNDED_TOKENS = %w[* n N unbounded].freeze
+
       def initialize(namespace: nil)
         @namespace = namespace
         @compiled = {}
@@ -43,20 +47,24 @@ module Lutaml
         @compiled
       end
 
-      def validate(input_or_instance, compiled: nil)
+      # Validate an instances document against compiled models.
+      #
+      # Accepts the instances input as a String, IO, StringIO, or a
+      # pre-parsed Document. If +compiled:+ is supplied, that registry is
+      # used; otherwise models are compiled from the same input (which
+      # must therefore contain a models section).
+      #
+      # Returns an array of validation error strings (empty if all pass).
+      def validate(input, compiled: nil)
+        doc = input.is_a?(Document) ? input : Pipeline.call(input, resolve: false)
         if compiled
           @compiled = compiled
-        elsif input_or_instance.is_a?(String) || input_or_instance.is_a?(IO) || input_or_instance.is_a?(StringIO)
-          doc = Pipeline.call(input_or_instance, resolve: false)
+        else
           compile_document(doc)
         end
+
         errors = []
-        instance = input_or_instance.is_a?(Lutaml::Lml::Instance) ? input_or_instance : nil
-        unless instance
-          doc ||= Pipeline.call(input_or_instance, resolve: false)
-          instance = doc.instance
-        end
-        validate_instance(instance, errors) if instance
+        validate_instance(doc.instance, errors) if doc.instance
         errors
       end
 
@@ -140,34 +148,28 @@ module Lutaml
       end
 
       def extract_raw_attributes(instance)
-        Array(instance.attributes).each_with_object({}) do |attr, hash|
-          if attr.instances.any?
-            hash[attr.name.to_sym] = attr.instances.map { |i| hydrate_instance(i) }
-          elsif attr.value.is_a?(Array)
-            hash[attr.name.to_sym] = attr.value
-          elsif !attr.value.nil?
-            hash[attr.name.to_sym] = attr.value
-          end
+        instance.each_attribute.each_with_object({}) do |(name, value, nested), hash|
+          hash[name.to_sym] = resolve_instance_value(value, nested)
         end
       end
 
       def extract_instance_attributes(instance, klass)
-        schema_keys = klass.attributes.keys
-        Array(instance.attributes).each_with_object({}) do |attr, hash|
-          key = attr.name.to_sym
+        schema_keys = klass.attributes.keys.to_set
+        instance.each_attribute.each_with_object({}) do |(name, value, nested), hash|
+          key = name.to_sym
           next unless schema_keys.include?(key)
 
-          hash[key] = coerce_attribute_value(attr, klass.attributes[key])
+          hash[key] = resolve_instance_value(value, nested)
         end
       end
 
-      def coerce_attribute_value(attr, _attr_def)
-        if attr.instances.any?
-          attr.instances.map { |i| hydrate_instance(i) }
-        elsif attr.value.is_a?(Array)
-          attr.value
-        elsif !attr.value.nil?
-          attr.value
+      def resolve_instance_value(value, nested)
+        if nested.any?
+          nested.map { |i| hydrate_instance(i) }
+        elsif value.is_a?(Array)
+          value
+        elsif !value.nil?
+          value
         end
       end
 
@@ -304,8 +306,10 @@ module Lutaml
 
       def parse_cardinality_value(val)
         return nil if val.nil?
-        return Float::INFINITY if val == "*" || val == "n"
-        val.to_i
+        return Float::INFINITY if UNBOUNDED_TOKENS.include?(val.to_s)
+        return val.to_i if val.to_s.match?(/\A\d+\z/)
+
+        raise ValidationError, "Unrecognized cardinality token: #{val.inspect}"
       end
 
       def extract_enum_values(enum_def)

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

@@ -8,6 +8,14 @@ module Lutaml
       attribute :instance, "Lutaml::Lml::Instance"
       attribute :template, "Lutaml::Lml::TopElementAttribute", collection: true
       attribute :parent, :string
+
+      def each_attribute
+        return enum_for(:each_attribute) unless block_given?
+
+        Array(attributes).each do |attr|
+          yield attr.name, attr.value, Array(attr.instances)
+        end
+      end
     end
   end
 end

data/lib/lutaml/lml/preprocessor.rb

@@ -38,17 +38,14 @@ module Lutaml
 
       def process_include_line(include_root, line)
         include_path_match = line.match(/^\s*include\s+(.+)/)
-        return line if include_path_match.nil? || line =~ /^\s\*\*/
+        return line if include_path_match.nil?
 
         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
-      rescue Errno::ENOENT
-        $stderr.puts(
-          "No such file or directory @ rb_sysopen - #{path_to_file}, " \
-          "include file paths need to be supplied relative to the main document"
-        )
+      rescue Errno::ENOENT, Errno::EACCES => e
+        warn "Skipping #{path_to_file}: #{e.message}"
         []
       end
     end

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.1.0"
+    VERSION = "0.1.1"
   end
 end

data/lib/lutaml/lml.rb

@@ -2,14 +2,15 @@
 
 require "lutaml/model"
 
-# Lutaml::Formatter and Lutaml::Layout are in the Lutaml top namespace,
-# not Lutaml::Lml. Require their namespace files to set up autoloads.
-require "lutaml/lml/formatter"
-require "lutaml/lml/layout"
-
 module Lutaml
   class Error < StandardError; end
 
+  # Lutaml::Formatter and Lutaml::Layout live in the Lutaml top namespace
+  # (not Lutaml::Lml) but their files are part of this gem. Declare the
+  # autoloads here so first reference loads them lazily.
+  autoload :Formatter, "lutaml/lml/formatter"
+  autoload :Layout, "lutaml/lml/layout"
+
   module Lml
     class Error < Lutaml::Error; end
     class ParsingError < Error; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ribose Inc.