lutaml-model 0.8.17 → 0.8.18

data/spec/lutaml/model/schema/renderers/model_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/model"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Model do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders a rooted element with one element attribute" do
+    spec = defs::Model.new(
+      class_name: "Person",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Person"),
+      members: [
+        defs::Attribute.new(
+          name: "name",
+          type: defs::TypeRef.new(kind: :symbol, value: "string"),
+          xml_name: "name",
+          kind: :element,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class Person < Lutaml::Model::Serializable")
+    expect(output).to include("attribute :name, :string")
+    expect(output).to include("xml do")
+    expect(output).to include('element "Person"')
+    expect(output).to include('map_element "name", to: :name')
+    expect(output).to include("def self.register")
+    expect(output).to include("Person.register_class_with_id")
+  end
+
+  it "renders a fragment (no element / type_name directive)" do
+    spec = defs::Model.new(
+      class_name: "Inner",
+      xml_root: defs::XmlRoot.new(kind: :fragment, name: nil),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).not_to include("element ")
+    expect(output).not_to include("type_name ")
+  end
+
+  it "renders an attribute mapping with map_attribute" do
+    spec = defs::Model.new(
+      class_name: "Item",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Item"),
+      members: [
+        defs::Attribute.new(
+          name: "id",
+          type: defs::TypeRef.new(kind: :symbol, value: "string"),
+          xml_name: "id",
+          kind: :attribute,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('map_attribute "id", to: :id')
+  end
+
+  it "renders a class reference type with no leading colon" do
+    spec = defs::Model.new(
+      class_name: "Owner",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Owner"),
+      members: [
+        defs::Attribute.new(
+          name: "address",
+          type: defs::TypeRef.new(kind: :class_ref, value: "Address"),
+          xml_name: "address",
+          kind: :element,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("attribute :address, Address")
+  end
+
+  it "renders a w3c type with the ::-prefixed reference" do
+    spec = defs::Model.new(
+      class_name: "Para",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Para"),
+      members: [
+        defs::Attribute.new(
+          name: "lang",
+          type: defs::TypeRef.new(kind: :w3c, value: "Lutaml::Xml::W3c::Lang"),
+          xml_name: "lang",
+          kind: :attribute,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("attribute :lang, ::Lutaml::Xml::W3c::Lang")
+  end
+
+  it "skips register methods inside a module_namespace" do
+    spec = defs::Model.new(
+      class_name: "Inside",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Inside"),
+    )
+
+    output = described_class.render(spec, module_namespace: "Mod::Sub")
+
+    expect(output).to include("module Mod")
+    expect(output).to include("module Sub")
+    expect(output).not_to include("def self.register")
+    expect(output).not_to include("register_class_with_id")
+  end
+
+  it "renders a choice block with attributes inside" do
+    spec = defs::Model.new(
+      class_name: "Either",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Either"),
+      members: [
+        defs::Choice.new(
+          header: "choice",
+          alternatives: [
+            defs::Attribute.new(
+              name: "alpha",
+              type: defs::TypeRef.new(kind: :symbol, value: "string"),
+              xml_name: "alpha",
+              kind: :element,
+            ),
+            defs::Attribute.new(
+              name: "beta",
+              type: defs::TypeRef.new(kind: :symbol, value: "string"),
+              xml_name: "beta",
+              kind: :element,
+            ),
+          ],
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("choice do")
+    expect(output).to include("attribute :alpha, :string")
+    expect(output).to include("attribute :beta, :string")
+  end
+end

data/spec/lutaml/model/schema/renderers/namespace_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/namespace"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Namespace do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders a namespace class with uri and prefix_default" do
+    spec = defs::Namespace.new(
+      class_name: "ExampleNs",
+      uri: "http://example.com/ns",
+      prefix_default: "ex",
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class ExampleNs < Lutaml::Xml::W3c::XmlNamespace")
+    expect(output).to include(%(uri "http://example.com/ns"))
+    expect(output).to include(%(prefix_default "ex"))
+  end
+
+  it "wraps in module when module_namespace is supplied" do
+    spec = defs::Namespace.new(
+      class_name: "Inner",
+      uri: "http://example.com/inner",
+      prefix_default: nil,
+    )
+
+    output = described_class.render(spec, module_namespace: "Mod::Sub")
+
+    expect(output).to include("module Mod")
+    expect(output).to include("module Sub")
+  end
+end

data/spec/lutaml/model/schema/renderers/restricted_type_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/restricted_type"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::RestrictedType do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders min/max facets in the cast body" do
+    spec = defs::RestrictedType.new(
+      class_name: "PositiveInt",
+      parent_class: "Lutaml::Model::Type::Integer",
+      facets: defs::Facet.new(min_inclusive: 1, max_inclusive: 100),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class PositiveInt < Lutaml::Model::Type::Integer")
+    expect(output).to include("def self.cast(value, options = {})")
+    expect(output).to include("options[:min] = 1")
+    expect(output).to include("options[:max] = 100")
+    expect(output).to include("value = super(value, options)")
+  end
+
+  it "renders enumerations facet" do
+    spec = defs::RestrictedType.new(
+      class_name: "Color",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new(enumerations: %w[red green blue]),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('options[:values] = [super("red"), super("green"), super("blue")]')
+    expect(output).not_to include("options[:min]")
+  end
+
+  it "renders pattern facet as a regexp literal" do
+    spec = defs::RestrictedType.new(
+      class_name: "Slug",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new(pattern: "[a-z0-9-]+"),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("options[:pattern] = %r{[a-z0-9-]+}")
+  end
+
+  it "renders transform facet" do
+    spec = defs::RestrictedType.new(
+      class_name: "Upper",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new,
+      transform_facet: defs::TransformFacet.new(expression: "value.upcase"),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("value = value.upcase")
+  end
+
+  it "uses lazy register memoisation" do
+    spec = defs::RestrictedType.new(
+      class_name: "Tiny",
+      parent_class: "Lutaml::Model::Type::Integer",
+      facets: defs::Facet.new(max_inclusive: 5),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("@register ||= Lutaml::Model::Config.default_register")
+  end
+end

data/spec/lutaml/model/schema/renderers/union_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/union"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Union do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders the :class_refs strategy as an each/begin/rescue loop" do
+    spec = defs::UnionType.new(
+      class_name: "NumberOrString",
+      members: [
+        defs::TypeRef.new(kind: :class_ref, value: "Integer"),
+        defs::TypeRef.new(kind: :class_ref, value: "String"),
+      ],
+      cast_strategy: :class_refs,
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class NumberOrString < Lutaml::Model::Type::Value")
+    expect(output).to include("[Integer, String].each do |t|")
+    expect(output).to include("casted = t.cast(value, options)")
+    expect(output).to include("return casted unless casted.nil?")
+    expect(output).to include("rescue StandardError")
+  end
+
+  it "renders the :resolve_type strategy as a ||-chained resolve_type call" do
+    spec = defs::UnionType.new(
+      class_name: "IntegerOrToken",
+      members: [
+        defs::TypeRef.new(kind: :symbol, value: "integer"),
+        defs::TypeRef.new(kind: :symbol, value: "token"),
+      ],
+      cast_strategy: :resolve_type,
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("Lutaml::Model::GlobalContext.resolve_type(:integer, @register).cast(value, options)")
+    expect(output).to include("Lutaml::Model::GlobalContext.resolve_type(:token, @register).cast(value, options)")
+    expect(output).to include(" ||\n")
+  end
+
+  it "emits required_files lines above the module wrap" do
+    spec = defs::UnionType.new(
+      class_name: "AnyOf",
+      members: [defs::TypeRef.new(kind: :class_ref, value: "Integer")],
+      cast_strategy: :class_refs,
+      required_files: ['require_relative "integer"'],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('require_relative "integer"')
+  end
+end

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+# Regression: Transform#apply_value_map must handle the nil-attr case used
+# by custom-method-only key-value rules. Pre-consolidation behavior:
+# the default { omitted: :nil, nil: :nil, empty: :empty } map converted
+# UninitializedClass.instance to nil so the downstream Utils.present? guard
+# in KeyValue::Transform#process_mapping_rule would skip the custom method
+# for absent input keys.
+RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
+  let(:transform_subclass) do
+    Class.new(described_class) do
+      # Expose the protected delegator for direct testing.
+      public :apply_value_map
+    end
+  end
+
+  let(:context) { Class.new(Lutaml::Model::Serializable) }
+  let(:register) { Lutaml::Model::Config.default_register }
+  let(:transform) { transform_subclass.new(context, register) }
+
+  let(:uninit) { Lutaml::Model::UninitializedClass.instance }
+  let(:default_vmap) { { omitted: :nil, nil: :nil, empty: :empty } }
+
+  describe "default mapping with nil attr" do
+    it "converts UninitializedClass to nil via the :omitted => :nil mapping" do
+      # Before the fix: returned uninit unchanged, causing Utils.present? to
+      # be true and the custom method to run for absent fields.
+      expect(transform.apply_value_map(uninit, default_vmap, nil)).to be_nil
+    end
+
+    it "converts nil to nil via the :nil => :nil mapping" do
+      expect(transform.apply_value_map(nil, default_vmap, nil)).to be_nil
+    end
+
+    it "passes initialized values through unchanged" do
+      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+    end
+  end
+
+  describe "explicit :omitted => :omitted with nil attr" do
+    let(:vmap) { { omitted: :omitted, nil: :nil, empty: :empty } }
+
+    it "preserves UninitializedClass for explicit omitted: :omitted" do
+      expect(transform.apply_value_map(uninit, vmap, nil)).to eq(uninit)
+    end
+  end
+
+  # Behavior-preservation: the pre-consolidation attribute-less path mapped the
+  # :omitted option to UninitializedClass.instance (present? => true, so the
+  # custom method runs), and resolved :nil/:empty consistently for empty inputs.
+  describe "non-:nil options with nil attr" do
+    it "maps a nil value to uninitialized via nil: :omitted" do
+      expect(transform.apply_value_map(nil, { nil: :omitted }, nil)).to eq(uninit)
+    end
+
+    it "maps an empty value to uninitialized via empty: :omitted" do
+      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+    end
+
+    it "maps an empty value to nil via empty: :nil" do
+      expect(transform.apply_value_map("", { empty: :nil }, nil)).to be_nil
+    end
+  end
+end