lutaml-model 0.8.117 → 0.8.119

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49af9f0bc6f8dd954e93d9d3ac641e212dbf526486c9c8a2eb3460ccfbf01cbf
-  data.tar.gz: cf20d264b0827b500c0dde7340b721c5ea89235341a55ef603f3e41dd461a31a
+  metadata.gz: 8df481bfb5303c05153a8bda8eaa4996157a6060d34d70dd8eb835e461aff9f5
+  data.tar.gz: a23f93de4f89b1a2b7925833786e9d0337ec5e94ec172723f5b2b70f78347d3c
 SHA512:
-  metadata.gz: 62359095df53c8835748e08c60c8648f6e07a4e892536da699ded2f255ec176a8aee3e648012d27e62909af5e34426118f465d93adf616ed005e22273e990fbc
-  data.tar.gz: 7e1d1f54a24252a44a31e2a0d45e878c13b9a5d44115a856aafd383cf24adb731ad585d52b8a8d9d648557ee150e2c0b776a1edd18b405bf16c79e76fbf4c2a8
+  metadata.gz: adbc819876bf696f60009c53042dba835e5e557f32057f1aba4f58da56831c15f347d35dcf0160536a877f29f2d17ba59aadb8b1ac38b7fa9572b2d12d6c6dd2
+  data.tar.gz: 9af887394f9b2e241f299cb8eabcc3e0202ec51dba5129477a16cb85234105f51c7198fc44b9c20c916fa89a1356918c4752bbd73afa8f83a5a49ffd3032f08d

data/lib/lutaml/json/adapter/yeptris_adapter.rb

@@ -27,16 +27,33 @@ module Lutaml
         private_class_method :require_engine
 
         # True where the yeptris engine loads (libyeptris present for
-        # this platform). Idempotent; a missing or broken install
-        # reports false instead of raising, so optional-engine callers
-        # can gate on it.
+        # this platform) AND answers a probe parse. A require alone
+        # does not prove the engine: a half-initialized Yeptris
+        # constant (the poison-process state the gem documents)
+        # passes const_defined? and require while every parse fails,
+        # and the native parse error then surfaces on valid input.
+        # Idempotent; a missing or broken install reports false
+        # instead of raising, so optional-engine callers (detection)
+        # can gate on it and fall back to the standard lane.
         def self.available?
           require_engine
-          true
+          native_ready?
         rescue LoadError
           false
         end
 
+        def self.native_ready?
+          return @native_ready unless @native_ready.nil?
+
+          @native_ready = begin
+            ::Yeptris::JSON.load('{"native_probe": 1}')
+            true
+          rescue ::Yeptris::Error, LoadError, NoMemoryError
+            false
+          end
+        end
+        private_class_method :native_ready?
+
         # The parse-error contract is the standard adapter's: invalid
         # input raises JSON::ParserError regardless of the engine, so
         # consumers' rescue ladders (and this gem's own

data/lib/lutaml/model/adapter_resolver.rb

@@ -387,13 +387,21 @@ module Lutaml
         end
 
         # Native key-value engine preference: yeptris (libyeptris C11)
-        # when its gem is in the bundle, else the format's standard
-        # adapter. Opt-in by bundle contents — nothing is required of
-        # consumers that do not add yeptris.
+        # when its gem is in the bundle AND the native engine answers a
+        # probe, else the format's standard adapter. Opt-in by bundle
+        # contents — nothing is required of consumers that do not add
+        # yeptris. The probe matters because a half-initialized Yeptris
+        # constant (the poison-process state the gem documents) passes
+        # const_defined? and require while every parse fails; without
+        # it the lane selection flips with process load order and the
+        # failure surfaces as a native parse error on valid input
+        # instead of a clean standard-lane parse (#978).
         def detect_yeptris_kv_adapter(format)
-          return metadata.dig(format, :default) if Lutaml::Model.opal?
+          default = metadata.dig(format, :default)
+          return default if Lutaml::Model.opal?
+          return default unless Utils.safe_load("yeptris", :Yeptris)
 
-          Utils.safe_load("yeptris", :Yeptris) ? :yeptris : metadata.dig(format, :default)
+          load_adapter(format, :yeptris).available? ? :yeptris : default
         end
 
         # Detect available XML adapter.

data/lib/lutaml/model/attribute.rb

@@ -5,6 +5,20 @@ module Lutaml
     class Attribute
       attr_reader :name, :options
 
+      # Format scalars a mapped-model attribute may be handed in the
+      # key-value lanes (#978). Adapter element nodes and other object
+      # forms belong to the mapping lane and must not divert.
+      SCALAR_CAST_TYPES = [
+        ::String,
+        ::Numeric,
+        ::Symbol,
+        ::Time,
+        ::Date,
+        ::DateTime,
+        ::TrueClass,
+        ::FalseClass,
+      ].freeze
+
       include CollectionHandler
       include DeepDupable
       include RestrictionValidation
@@ -982,9 +996,11 @@ instance_object = nil)
         # String, #978). A type declaring its own .cast owns scalar
         # construction; base-cast identity types fall through to the
         # legacy conversion chain, whose parse error names the token.
+        # Non-scalar input (adapter elements, hashes, arrays) rides
+        # the mapping lane untouched.
         if serializable_type?(register) && !value.nil? &&
-            !value.is_a?(::Hash) && !value.is_a?(::Array) &&
-            !value.respond_to?(:key?) && klass.respond_to?(:cast) &&
+            SCALAR_CAST_TYPES.any? { |type| value.is_a?(type) } &&
+            klass.respond_to?(:cast) &&
             klass.method(:cast).owner == klass.singleton_class
           casted = klass.cast(value)
           return casted if casted.is_a?(klass)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.117"
+    VERSION = "0.8.119"
   end
 end

data/lib/lutaml/yaml/adapter/yeptris_adapter.rb

@@ -41,16 +41,34 @@ module Lutaml
         private_class_method :require_engine
 
         # True where the yeptris engine loads (libyeptris present for
-        # this platform). Idempotent; a missing or broken install
-        # reports false instead of raising, so optional-engine callers
-        # can gate on it.
+        # this platform) AND answers a probe parse. A require alone
+        # does not prove the engine: a half-initialized Yeptris
+        # constant (the poison-process state the gem documents)
+        # passes const_defined? and require while every parse fails,
+        # and the native parse error then surfaces on valid input.
+        # Idempotent; a missing or broken install reports false
+        # instead of raising, so optional-engine callers (detection)
+        # can gate on it and fall back to the standard lane.
         def self.available?
           require_engine
-          true
+          native_ready?
         rescue LoadError
           false
         end
 
+        def self.native_ready?
+          return @native_ready unless @native_ready.nil?
+
+          @native_ready = begin
+            # rubocop:disable-next Naming/VariableNumber -- upstream schema literal
+            ::Yeptris::YAML.load("native_probe: 1", schema: :compat_11)
+            true
+          rescue ::Yeptris::Error, LoadError, NoMemoryError
+            false
+          end
+        end
+        private_class_method :native_ready?
+
         # The parse-error contract is the standard adapter's: invalid
         # input raises Psych::SyntaxError regardless of the engine, so
         # consumers' rescue ladders (and this gem's own

data/spec/lutaml/model/cast_element_form_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# The scalar-cast diversion (#978) must not capture element-form input:
+# a type declaring its own .cast still receives parsed child elements
+# through the mapping lane, which builds the model from its XML
+# mapping. Diverting those into .cast raised IncorrectModelError
+# downstream (uniword shared-schemas round-trips on 0.8.116/0.8.117).
+RSpec.describe "cast routing for element-form input" do
+  let(:styled_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :value, :string
+
+      xml do
+        element "style"
+        map_attribute "value", to: :value
+      end
+
+      key_value do
+        map "value", to: :value
+      end
+
+      def self.cast(value)
+        return value if value.is_a?(self)
+
+        new(value: value.to_s)
+      end
+    end
+  end
+
+  let(:host_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :style, "CastStyled"
+
+      xml do
+        element "host"
+        map_element "style", to: :style
+      end
+    end
+  end
+
+  before do
+    stub_const("CastStyled", styled_class)
+    stub_const("CastHost", host_class)
+  end
+
+  it "builds element-form input through the mapping lane" do
+    model = CastHost.from_xml('<host><style value="normal"/></host>')
+
+    expect(model.style).to be_a(CastStyled)
+    expect(model.style.value).to eq("normal")
+  end
+end

data/spec/lutaml/model/yeptris_native_detection_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "open3"
+require "lutaml/json/adapter/yeptris_adapter"
+
+# Surface 1 of #978: the yeptris lane was selected from a bare
+# constant check, so a process holding a half-initialized Yeptris
+# module (the poison-process state the gem documents) committed to
+# the native lane and failed pre-mapping on valid JSON — while other
+# processes fell back to the standard lane, flipping the adapter
+# choice across runs. Detection now probes the native engine; a
+# broken native deterministically rides the standard lane.
+RSpec.describe Lutaml::Model::AdapterResolver, ".adapter_for yeptris native detection" do
+  let(:parse_probe) do
+    <<~RUBY
+      require "lutaml/model"
+
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :v, :string
+        key_value { map "v", to: :v }
+      end
+
+      model = klass.from_json('{"v": "scalar"}')
+      adapter = Lutaml::Model::AdapterResolver.adapter_for(:json)
+      puts "ADAPTER=\#{adapter.name.split('::').last} PARSED=\#{model.v}"
+    RUBY
+  end
+
+  def subprocess_yeptris_capable?
+    probe = <<~RUBY
+      begin
+        require "yeptris"
+        exit(0)
+      rescue LoadError
+        exit(1)
+      end
+    RUBY
+    _out, _err, status = Open3.capture3(RbConfig.ruby, "-I", "lib", "-e", probe)
+    status.success?
+  end
+
+  it "resolves the yeptris lane when the native engine answers a probe" do
+    skip "optional yeptris engine not resolvable outside the bundle" unless subprocess_yeptris_capable?
+
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", "lib", "-e", parse_probe)
+    expect(status).to be_success, stderr
+    expect(stdout).to include("ADAPTER=YeptrisAdapter")
+    expect(stdout).to include("PARSED=scalar")
+  end
+
+  it "falls back to the standard lane when the native engine cannot parse" do
+    poison = <<~RUBY
+      require "lutaml/model"
+      require "yeptris"
+      require "lutaml/json/adapter/yeptris_adapter"
+
+      # The poison state: the module is defined and require succeeds,
+      # but every native parse fails. Whatever the cause (a stale
+      # libyeptris, a half-initialized load), the lane must not be
+      # selected.
+      Lutaml::Json::Adapter::YeptrisAdapter
+        .define_singleton_method(:native_ready?) { false }
+
+      #{parse_probe}
+    RUBY
+
+    stdout, stderr, status = Open3.capture3(RbConfig.ruby, "-I", "lib", "-e", poison)
+    expect(status).to be_success, stderr
+    expect(stdout).to include("ADAPTER=StandardAdapter")
+    expect(stdout).to include("PARSED=scalar")
+  end
+
+  it "reports the adapter unavailable when the native probe fails" do
+    allow(Lutaml::Json::Adapter::YeptrisAdapter)
+      .to receive(:native_ready?).and_return(false)
+
+    expect(Lutaml::Json::Adapter::YeptrisAdapter.available?).to be(false)
+  ensure
+    allow(Lutaml::Json::Adapter::YeptrisAdapter)
+      .to receive(:native_ready?).and_call_original
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.117
+  version: 0.8.119
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-19 00:00:00.000000000 Z
+date: 2026-10-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1713,6 +1713,7 @@ files:
 - spec/lutaml/model/boot_manifest_spec.rb
 - spec/lutaml/model/cached_type_resolver_spec.rb
 - spec/lutaml/model/cardinality_strict_spec.rb
+- spec/lutaml/model/cast_element_form_spec.rb
 - spec/lutaml/model/cdata_spec.rb
 - spec/lutaml/model/choice_restrict_spec.rb
 - spec/lutaml/model/choice_spec.rb
@@ -1899,6 +1900,7 @@ files:
 - spec/lutaml/model/yamls_sequence_spec.rb
 - spec/lutaml/model/yamls_spec.rb
 - spec/lutaml/model/yeptris_error_parity_spec.rb
+- spec/lutaml/model/yeptris_native_detection_spec.rb
 - spec/lutaml/model_spec.rb
 - spec/lutaml/rdf/context_spec.rb
 - spec/lutaml/rdf/graph_serialization_spec.rb