lutaml-lml 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 848b5d75872b444720cee8fb6cdc2ae93db738657cb8ad13633d0317d8bd9808
-  data.tar.gz: f9718ba7428f4948d06bf8e489d55d78584c95086ebc4ff6ea6fb2bd0c0e41a9
+  metadata.gz: f72188a69457d2cf82445867f2b726dd621d63e82d79c7e56b01241e0d15ec84
+  data.tar.gz: 402135ddb2bf31953c21f6166c859c6b5f67d24d1a9e18e8369eb3646a413381
 SHA512:
-  metadata.gz: adae7746cdcf26e0709537239e7a4cc234c9287f49615eca76d44add023d11d317b30754ac9fef8d1dd6fbbc0899d19a77c284aa3726b6f8809b9f49ea440b4a
-  data.tar.gz: ac7189d5cef1e567485b38b56e23998961280600d157c037e8e21def73ee41e22f632ff82c0ab298c286319c00ab74d9a71e6d3fe0f4e9669ea8644cdd7b03ba
+  metadata.gz: d07e5279b6c0d983d1ba1384ef3579aa3d493fba0520aedadfd97ac11a42bfca1fd2e96e621e6551e8dd22bef52e30136779cdf88e8bbe81e611b762e1efa3cd
+  data.tar.gz: 20e402c37d1506fd86c4ded5fac0bb010dc58d3cdda8efcf3e92cd287ec8025331375310b7e40093741af136aaaf4f61d78a44456fe59b2d75dffe5e1d57568b

data/lib/lutaml/lml/data_processor/attribute_processing.rb

@@ -14,6 +14,7 @@ module Lutaml
         end
 
         def process_attributes_array(obj)
+          return [] if obj.empty?
           return obj.map { |item| process_attributes(item) } unless single_key_hashes?(obj)
 
           obj.each_with_object({}) do |item, hash|

data/lib/lutaml/lml/data_processor/instance_processing.rb

@@ -26,8 +26,7 @@ module Lutaml
             key = INSTANCE_KEY_HANDLERS.keys.find { |k| instance.key?(k) }
             next unless key
 
-            result = public_send(INSTANCE_KEY_HANDLERS[key], instance[key])
-            key == :instance ? (acc[:instances] << result) : (acc[key] = result)
+            append_result(acc, key, public_send(INSTANCE_KEY_HANDLERS[key], instance[key]))
           end
         end
 
@@ -57,6 +56,16 @@ module Lutaml
         def handle_instance_template(value, result)
           result[:template] = process_attributes(value[:attributes])
         end
+
+        private
+
+        def append_result(acc, key, result)
+          case key
+          when :instance then acc[:instances] << result
+          when :collections then (acc[:collections] ||= []) << result
+          else (acc[key] ||= []).concat(result)
+          end
+        end
       end
     end
   end

data/lib/lutaml/lml/executor/condition_evaluator.rb

@@ -30,8 +30,8 @@ module Lutaml
         # Evaluate all validation conditions against a collection of instances.
         # Returns an array of error strings (empty if all pass).
         def self.evaluate(collection, instances)
-          return [] unless collection.validations&.any?
           return [] unless collection.is_a?(Collection)
+          return [] unless collection.validations&.any?
 
           new(instances).evaluate_all(collection.validations)
         end

data/lib/lutaml/lml/executor.rb

@@ -73,10 +73,9 @@ module Lutaml
       def validate_collections(doc, instances)
         return [] unless doc.instances&.collections
 
-        collection = doc.instances.collections
-        return [] unless collection.is_a?(Collection)
-
-        ConditionEvaluator.evaluate(collection, instances)
+        Array(doc.instances.collections).flat_map do |collection|
+          ConditionEvaluator.evaluate(collection, instances)
+        end
       end
 
       # --- Export ---

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

@@ -19,12 +19,18 @@ module Lutaml
           rule(:whitespace?) { whitespace.maybe }
           rule(:newline) { match('[\r\n]') }
 
-          rule(:quoted_string_content) do
-            (str('"').absent? >> any).repeat
+          # Body of a string delimited by `char`, captured as `label`.
+          def quoted(char, label)
+            str(char) >> (str(char).absent? >> any).repeat.as(label) >> str(char)
           end
-          rule(:quoted_string) do
-            str('"') >> quoted_string_content.as(:string) >> str('"')
+
+          # A string in either quote style. Delimiters must match, so `"a'`
+          # stays a parse error.
+          def any_quoted(label)
+            quoted('"', label) | quoted("'", label)
           end
+
+          rule(:quoted_string) { any_quoted(:string) }
           rule(:boolean) { (str("true") | str("false")).as(:boolean) }
           rule(:number) { (match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)).as(:float) | match("[0-9]").repeat(1).as(:number) }
           rule(:variable) { (quoted_string | match("[a-zA-Z0-9_]").repeat(1)) }

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

@@ -22,9 +22,7 @@ module Lutaml
           end
 
           rule(:view_import) do
-            kw_view_import >>
-              str('"') >> quoted_string_content.as(:path) >> str('"') >>
-              whitespace?
+            kw_view_import >> any_quoted(:path) >> whitespace?
           end
 
           # Entity names in show/hide lists must be space-free: general

data/lib/lutaml/lml/literal_value.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Lutaml
+  module Lml
+    # The type of an LML attribute literal: a scalar, a list, or a map.
+    #
+    # This exists as a subclass rather than using Lutaml::Model::Type::Value
+    # directly because lutaml-model's key-value serializer tests the declared
+    # attribute type with a strict `attribute_type < Type::Value`. Type::Value
+    # is not a strict subclass of itself, so declaring it hands the serializer
+    # the raw wrapper object: JSON calls to_json(state) on it and raises
+    # ArgumentError, and Psych emits a !ruby/object tag that from_yaml then
+    # refuses to load. A subclass puts the attribute on the working path, where
+    # the serializer asks the wrapper for its value instead.
+    #
+    # Deleting this class needs two upstream changes, not one: that `<` widened
+    # to `<=`, and the serializer no longer re-wrapping a value it already
+    # wrapped. Widening `<` alone still leaves the nested wrapper below.
+    class LiteralValue < Lutaml::Model::Type::Value
+      # The serializer re-wraps an already-wrapped value before asking it for a
+      # format, so #value has to see through that extra layer. Every to_<format>
+      # method lutaml-model generates reads through here, which is why this is
+      # one override rather than one per format.
+      def value
+        wrapped = super
+        wrapped.is_a?(LiteralValue) ? wrapped.value : wrapped
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module Lutaml
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: []
       attribute :imports, "Lutaml::Lml::InstancesImport", collection: true, default: []
       attribute :exports, "Lutaml::Lml::InstancesExport", collection: true, default: []
-      attribute :collections, "Lutaml::Lml::Collection", default: []
+      attribute :collections, "Lutaml::Lml::Collection", collection: true, default: []
     end
   end
 end

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

@@ -22,10 +22,73 @@ module Lutaml
 
       # LML-specific attributes
       attribute :properties, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
-      attribute :value, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
+      attribute :value, LiteralValue
       attribute :attributes, "Lutaml::Lml::TopElementAttribute", collection: true, default: -> { [] }
       attribute :extended, :boolean
       attribute :instances, "Lutaml::Lml::Instance", collection: true, default: -> { [] }
+
+      # Declared in full because a mapping block replaces the defaults. The
+      # rules below are the defaults, 1:1, except for `value`.
+      #
+      # `value` needs custom methods because a list literal reaches the model
+      # as a bare Array, and lutaml-model refuses one on a non-collection
+      # attribute: Attribute#cast splits it, then valid_collection! raises
+      # CollectionTrueMissingError. A custom `from` returns before that check,
+      # so a non-empty list survives a round trip without changing the
+      # serialized form. An empty list still does not: the transform skips a
+      # blank value before reaching the custom method, so `[]` reloads as nil.
+      key_value do
+        map "name", to: :name
+        map "visibility", to: :visibility
+        map "type", to: :type
+        map "id", to: :id
+        map "contain", to: :contain
+        map "static", to: :static
+        map "cardinality", to: :cardinality
+        map "keyword", to: :keyword
+        map "is_derived", to: :is_derived
+        map "is_static", to: :is_static
+        map "is_read_only", to: :is_read_only
+        map "stereotype", to: :stereotype
+        map "definition", to: :definition
+        map "association", to: :association
+        map "default", to: :default
+        map "properties", to: :properties
+        map "value", to: :value, with: { to: :value_to, from: :value_from }
+        map "attributes", to: :attributes
+        map "extended", to: :extended
+        map "instances", to: :instances
+      end
+
+      # Public because lutaml-model invokes mapping methods via public_send.
+      #
+      # Skipping nil keeps the key out of the output, which is what the default
+      # mapping does. `false` is a real literal, so the guard tests for nil
+      # rather than truthiness.
+      def value_to(model, doc)
+        literal = model.value
+        return if literal.nil?
+
+        doc["value"] = unwrap_literal(literal)
+      end
+
+      # lutaml-model runs this on a throwaway mapper instance, so `self` is not
+      # the object being deserialized - `model` is. Writing to `self.value`
+      # here would update an object that is discarded a moment later.
+      def value_from(model, value)
+        model.value = value
+      end
+
+      private
+
+      # A LiteralValue sits at the top level for a map literal, and inside the
+      # array for a list of references. Writing one through unwrapped raises
+      # ArgumentError in the adapter.
+      def unwrap_literal(value)
+        return value.map { |item| unwrap_literal(item) } if value.is_a?(::Array)
+
+        value.is_a?(LiteralValue) ? value.value : value
+      end
     end
   end
 end

data/lib/lutaml/lml/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Lml
-    VERSION = "0.1.3"
+    VERSION = "0.1.4"
   end
 end

data/lib/lutaml/lml.rb

@@ -52,6 +52,9 @@ module Lutaml
     autoload :HasAttributes, "lutaml/lml/has_attributes"
     autoload :VERSION, "lutaml/lml/version"
 
+    # Type classes (Lutaml::Model::Type::Value subclasses, not models)
+    autoload :LiteralValue, "lutaml/lml/literal_value"
+
     # Model classes (in Lutaml::Lml namespace, files in models/ directory)
     autoload :Action, "lutaml/lml/models/action"
     autoload :Association, "lutaml/lml/models/association"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-lml
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Ribose Inc.
@@ -123,6 +123,7 @@ files:
 - lib/lutaml/lml/layout.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/models/action.rb
 - lib/lutaml/lml/models/association.rb