lutaml-model 0.7.3 → 0.7.6

data/spec/lutaml/model/schema/yaml_schema_spec.rb

@@ -1,7 +1,7 @@
 require "spec_helper"
 require "lutaml/model/schema"
 
-module SchemaGeneration
+module YamlSchemaSpec
   class Glaze < Lutaml::Model::Serializable
     attribute :color, Lutaml::Model::Type::String
     attribute :finish, Lutaml::Model::Type::String
@@ -13,35 +13,258 @@ module SchemaGeneration
     attribute :glaze, Glaze
     attribute :materials, Lutaml::Model::Type::String, collection: true
   end
+
+  class ChoiceModel < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String
+    attribute :email, Lutaml::Model::Type::String
+    attribute :phone, Lutaml::Model::Type::String
+
+    choice(min: 1, max: 2) do
+      attribute :email, Lutaml::Model::Type::String
+      attribute :phone, Lutaml::Model::Type::String
+    end
+  end
+
+  class ValidationModel < Lutaml::Model::Serializable
+    attribute :name, Lutaml::Model::Type::String, values: %w[Alice Bob Charlie]
+    attribute :email, Lutaml::Model::Type::String, pattern: /.*?\S+@.+\.\S+/
+    attribute :age, Lutaml::Model::Type::Integer, collection: 1..3
+    attribute :score, Lutaml::Model::Type::Float, default: 0.0
+  end
+
+  class Shape < Lutaml::Model::Serializable
+    attribute :area, :float
+  end
+
+  class Circle < Shape
+    attribute :radius, Lutaml::Model::Type::Float
+  end
+
+  class Square < Shape
+    attribute :side, Lutaml::Model::Type::Float
+  end
+
+  class PolymorphicModel < Lutaml::Model::Serializable
+    attribute :shape, Shape, polymorphic: [Circle, Square]
+  end
 end
 
 RSpec.describe Lutaml::Model::Schema::YamlSchema do
   describe ".generate" do
-    it "generates a YAML schema for nested Serialize objects" do
-      schema = described_class.generate(SchemaGeneration::Vase)
-
-      expected_schema = <<~YAML
-        ---
-        type: map
-        mapping:
-          height:
-            type: float
-          diameter:
-            type: float
-          glaze:
-            type: map
-            mapping:
-              color:
-                type: str
-              finish:
-                type: str
-          materials:
-            type: seq
-            sequence:
-            - type: str
-      YAML
-
-      expect(schema).to eq(expected_schema)
+    context "with basic model" do
+      let(:schema) do
+        described_class.generate(
+          YamlSchemaSpec::Vase,
+          id: "http://stsci.edu/schemas/yaml-schema/draft-01",
+          description: "A vase schema",
+        )
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$id": http://stsci.edu/schemas/yaml-schema/draft-01
+          description: A vase schema
+          "$ref": "#/$defs/YamlSchemaSpec_Vase"
+          "$defs":
+            YamlSchemaSpec_Vase:
+              type: object
+              additionalProperties: false
+              properties:
+                height:
+                  type:
+                  - number
+                  - 'null'
+                diameter:
+                  type:
+                  - number
+                  - 'null'
+                glaze:
+                  "$ref": "#/$defs/YamlSchemaSpec_Glaze"
+                materials:
+                  type: array
+                  items:
+                    type: string
+            YamlSchemaSpec_Glaze:
+              type: object
+              additionalProperties: false
+              properties:
+                color:
+                  type:
+                  - string
+                  - 'null'
+                finish:
+                  type:
+                  - string
+                  - 'null'
+
+        YAML
+      end
+
+      it "generates a YAML schema for nested Serialize objects" do
+        expect(schema).to eq(expected_schema)
+      end
+    end
+
+    context "with choice validation" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::ChoiceModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_ChoiceModel"
+          "$defs":
+            YamlSchemaSpec_ChoiceModel:
+              type: object
+              additionalProperties: false
+              properties:
+                name:
+                  type:
+                  - string
+                  - 'null'
+                email:
+                  type:
+                  - string
+                  - 'null'
+                phone:
+                  type:
+                  - string
+                  - 'null'
+              oneOf:
+              - type: object
+                properties:
+                  email:
+                    type:
+                    - string
+                    - 'null'
+                  phone:
+                    type:
+                    - string
+                    - 'null'
+        YAML
+      end
+
+      it "generates a YAML schema with choice constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
+    end
+
+    context "with validation constraints" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::ValidationModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_ValidationModel"
+          "$defs":
+            YamlSchemaSpec_ValidationModel:
+              type: object
+              additionalProperties: false
+              properties:
+                name:
+                  type:
+                  - string
+                  - 'null'
+                  enum:
+                  - Alice
+                  - Bob
+                  - Charlie
+                email:
+                  type:
+                  - string
+                  - 'null'
+                  pattern: ".*?\\\\S+@.+\\\\.\\\\S+"
+                age:
+                  type: array
+                  items:
+                    type: integer
+                  minItems: 1
+                  maxItems: 3
+                score:
+                  type:
+                  - number
+                  - 'null'
+                  default: 0.0
+        YAML
+      end
+
+      it "generates a YAML schema with validation constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
+    end
+
+    context "with polymorphic types" do
+      let(:schema) do
+        described_class.generate(YamlSchemaSpec::PolymorphicModel)
+      end
+
+      let(:expected_schema) do
+        <<~YAML
+          %YAML 1.1
+          ---
+          "$schema": https://json-schema.org/draft/2020-12/schema
+          "$ref": "#/$defs/YamlSchemaSpec_PolymorphicModel"
+          "$defs":
+            YamlSchemaSpec_PolymorphicModel:
+              type: object
+              additionalProperties: false
+              properties:
+                shape:
+                  type:
+                  - object
+                  - 'null'
+                  oneOf:
+                  - "$ref": "#/$defs/YamlSchemaSpec_Circle"
+                  - "$ref": "#/$defs/YamlSchemaSpec_Square"
+                  - "$ref": "#/$defs/YamlSchemaSpec_Shape"
+            YamlSchemaSpec_Shape:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+            YamlSchemaSpec_Circle:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+                radius:
+                  type:
+                  - number
+                  - 'null'
+            YamlSchemaSpec_Square:
+              type: object
+              additionalProperties: false
+              properties:
+                area:
+                  type:
+                  - number
+                  - 'null'
+                side:
+                  type:
+                  - number
+                  - 'null'
+        YAML
+      end
+
+      it "generates a YAML schema with polymorphic type constraints" do
+        expect(schema.strip).to eq(expected_schema.strip)
+      end
     end
   end
 end

data/spec/lutaml/model/sequence_spec.rb

@@ -50,6 +50,17 @@ module SequenceSpec
       map_element "ceramic", to: :ceramic
     end
   end
+
+  class CeramicRestricted < Ceramic
+    restrict :id, collection: 0..1
+    restrict :name, collection: 0..1
+    restrict :type, collection: 0..1
+    restrict :color, collection: 0..1
+    restrict :bold, collection: 0..1
+    restrict :text, collection: 0..1
+    restrict :usage, collection: 0..1
+    restrict :size, collection: 1..2
+  end
 end
 
 RSpec.describe "Sequence" do
@@ -229,4 +240,29 @@ RSpec.describe "Sequence" do
       end.to raise_error(Lutaml::Model::UnknownSequenceMappingError, "map_attribute is not allowed in sequence")
     end
   end
+
+  describe "#validate_content!" do
+    let(:sequence) { SequenceSpec::CeramicRestricted.mappings_for(:xml).element_sequence[0] }
+    let(:klass) { SequenceSpec::CeramicRestricted }
+
+    it "does not raise for correct order" do
+      expect { sequence.validate_content!(["tag", "id", "name", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .not_to raise_error
+    end
+
+    it "raises for incorrect order" do
+      expect { sequence.validate_content!(["tag", "name", "id", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .to raise_error(Lutaml::Model::IncorrectSequenceError)
+    end
+
+    it "raises for unknown tag" do
+      expect { sequence.validate_content!(["tag", "id", "name", "foo", "type", "color", "bold", "text", "usage", "size"], klass) }
+        .to raise_error(Lutaml::Model::IncorrectSequenceError)
+    end
+
+    it "raises error for missing required tag" do
+      expect { sequence.validate_content!(["tag", "id", "name", "type", "color", "bold", "text", "usage"], klass) }
+        .to raise_error(Lutaml::Model::ElementCountOutOfRangeError)
+    end
+  end
 end

data/spec/lutaml/model/serializable_spec.rb

@@ -193,6 +193,37 @@ RSpec.describe Lutaml::Model::Serializable do
     end
   end
 
+  describe ".restrict" do
+    before do
+      stub_const("RestrictTestClass", Class.new(described_class))
+      RestrictTestClass.attribute(:foo, :string, collection: 1..3, values: [1, 2, 3])
+    end
+
+    it "merges new options into the attribute's options" do
+      expect { RestrictTestClass.restrict(:foo, collection: 2..4) }
+        .to change { RestrictTestClass.attributes[:foo].options[:collection] }
+        .from(1..3).to(2..4)
+
+      expect(RestrictTestClass.attributes[:foo].options[:values]).to eq([1, 2, 3])
+    end
+
+    it "does not remove existing options not specified in restrict" do
+      RestrictTestClass.restrict(:foo, collection: 5..6, values: [4, 5, 6])
+      expect(RestrictTestClass.attributes[:foo].options[:collection]).to eq(5..6)
+      expect(RestrictTestClass.attributes[:foo].options[:values]).to eq([4, 5, 6])
+    end
+
+    it "raises an error for invalid options" do
+      expect { RestrictTestClass.restrict(:foo, new_option: :bar) }
+        .to raise_error(Lutaml::Model::InvalidAttributeOptionsError, "Invalid options given for `foo` [:new_option]")
+    end
+
+    it "raises an error if the attribute does not exist" do
+      expect { RestrictTestClass.restrict(:bar, collection: 1..2) }
+        .to raise_error(NoMethodError)
+    end
+  end
+
   describe ".mappings_for" do
     context "when mapping is defined" do
       it "returns the defined mapping" do

data/spec/lutaml/model/type_spec.rb

@@ -198,7 +198,7 @@ RSpec.describe Lutaml::Model::Type do
 
         it "raises TypeNotEnabledError when using Decimal type" do
           expect do
-            described_class.lookup(:decimal).cast("123.45")
+            decimal_class.cast("123.45")
           end.to raise_error(Lutaml::Model::TypeNotEnabledError)
         end
       end
@@ -342,11 +342,14 @@ RSpec.describe Lutaml::Model::Type do
         expected_xml = <<~XML
           <sample custom_type="to_xml_overrided"/>
         XML
-        expect(sample_instance_attribute.to_xml).to be_equivalent_to(expected_xml)
+        expect(
+          sample_instance_attribute.to_xml,
+        ).to be_equivalent_to(expected_xml)
       end
 
       it "correctly serializes to JSON" do
-        expect(sample_instance.to_json).to eq('{"custom_type":"to_json_overrided"}')
+        expected_value = '{"custom_type":"to_json_overrided"}'
+        expect(sample_instance.to_json).to eq(expected_value)
       end
 
       it "correctly deserializes from XML" do
@@ -354,7 +357,8 @@ RSpec.describe Lutaml::Model::Type do
       end
 
       it "correctly deserializes from JSON" do
-        json_sample_instance = SampleModel.from_json('{"custom_type":"test_string"}')
+        json_input = '{"custom_type":"test_string"}'
+        json_sample_instance = SampleModel.from_json(json_input)
         json_sample_instance.to_json
         expect(json_sample_instance.custom_type).to eq("from_json_overrided")
       end

data/spec/lutaml/model/utils_spec.rb

@@ -37,9 +37,9 @@ RSpec.describe Lutaml::Model::Utils do
     "HelloWorld::FooBarBaz" => "hello_world/foo_bar_baz",
   }
 
-  include_examples "string conversion", :camel_case, camel_case_examples
-  include_examples "string conversion", :classify, classify_examples
-  include_examples "string conversion", :snake_case, snake_case_examples
+  it_behaves_like "string conversion", :camel_case, camel_case_examples
+  it_behaves_like "string conversion", :classify, classify_examples
+  it_behaves_like "string conversion", :snake_case, snake_case_examples
 
   describe ".deep_dup" do
     let(:original_hash) do

data/spec/lutaml/model/xml/derived_attributes_spec.rb

@@ -5,7 +5,7 @@ require "spec_helper"
 module DerivedAttributesSpecs
   class Ceramic < Lutaml::Model::Serializable
     attribute :name, :string
-    attribute :value, :float
+    attribute :value, register(:float)
   end
 
   class CeramicCollection < Lutaml::Model::Serializable

data/spec/lutaml/model/xml/root_mappings/nested_child_mappings_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+module NestedChildMappingsSpec
+  class ManifestFont < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :styles, :string, collection: true
+
+    key_value do
+      map "name", to: :name
+      map "styles", to: :styles
+    end
+  end
+
+  class ManifestResponseFontStyle < Lutaml::Model::Serializable
+    attribute :full_name, :string
+    attribute :type, :string
+    attribute :paths, :string, collection: true
+
+    key_value do
+      map "full_name", to: :full_name
+      map "type", to: :type
+      map "paths", to: :paths
+    end
+  end
+
+  class ManifestResponseFont < ManifestFont
+    attribute :name, :string
+    attribute :styles, ManifestResponseFontStyle, collection: true
+
+    key_value do
+      map "name", to: :name
+      map "styles", to: :styles, child_mappings: {
+        type: :key,
+        full_name: :full_name,
+        paths: :paths,
+      }
+    end
+  end
+
+  class ManifestResponse < Lutaml::Model::Collection
+    instances :fonts, ManifestResponseFont
+
+    key_value do
+      map to: :fonts, root_mappings: {
+        name: :key,
+        styles: :value,
+      }
+    end
+  end
+end
+
+RSpec.describe "NestedChildMappingsSpec" do
+  let(:yaml) do
+    <<~YAML
+      ---
+      Yu Gothic:
+        Bold:
+          full_name: Yu Gothic Bold
+          paths:
+          - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothB.ttc"
+          - "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothB.ttc"
+        Regular:
+          full_name: Yu Gothic Regular
+          paths:
+          - "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothR.ttc"
+          - "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothR.ttc"
+      Noto Sans Condensed:
+        Regular:
+          full_name: Noto Sans Condensed
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-Condensed.ttf"
+        Bold:
+          full_name: Noto Sans Condensed Bold
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedBold.ttf"
+        Bold Italic:
+          full_name: Noto Sans Condensed Bold Italic
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedBoldItalic.ttf"
+        Italic:
+          full_name: Noto Sans Condensed Italic
+          paths:
+          - "/Users/foo/.fontist/fonts/NotoSans-CondensedItalic.ttf"
+    YAML
+  end
+
+  let(:parsed_yaml) do
+    NestedChildMappingsSpec::ManifestResponse.from_yaml(yaml)
+  end
+
+  let(:expected_fonts) do
+    NestedChildMappingsSpec::ManifestResponse.new(
+      [
+        NestedChildMappingsSpec::ManifestResponseFont.new(
+          name: "Yu Gothic",
+          styles: [
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Yu Gothic Bold",
+              type: "Bold",
+              paths: [
+                "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothB.ttc",
+                "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothB.ttc",
+              ],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Yu Gothic Regular",
+              type: "Regular",
+              paths: [
+                "/Applications/Microsoft Excel.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft OneNote.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft Outlook.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft PowerPoint.app/Contents/Resources/DFonts/YuGothR.ttc",
+                "/Applications/Microsoft Word.app/Contents/Resources/DFonts/YuGothR.ttc",
+              ],
+            ),
+          ],
+        ),
+        NestedChildMappingsSpec::ManifestResponseFont.new(
+          name: "Noto Sans Condensed",
+          styles: [
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed",
+              type: "Regular",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-Condensed.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Bold",
+              type: "Bold",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedBold.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Bold Italic",
+              type: "Bold Italic",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedBoldItalic.ttf"],
+            ),
+            NestedChildMappingsSpec::ManifestResponseFontStyle.new(
+              full_name: "Noto Sans Condensed Italic",
+              type: "Italic",
+              paths: ["/Users/foo/.fontist/fonts/NotoSans-CondensedItalic.ttf"],
+            ),
+          ],
+        ),
+      ],
+    )
+  end
+
+  it "parses nested child mappings correctly" do
+    expect(parsed_yaml).to eq(expected_fonts)
+  end
+
+  it "rounds trip correctly" do
+    expected_yaml = parsed_yaml.to_yaml
+    expect(expected_yaml).to eq(yaml)
+  end
+end

data/spec/lutaml/model/xml/xml_element_spec.rb

@@ -88,6 +88,12 @@ RSpec.describe "XmlElement" do
   end
 
   def create_element(name, attributes: {}, children: [], text: "")
-    Lutaml::Model::Xml::XmlElement.new(name, attributes, children, text)
+    Lutaml::Model::Xml::XmlElement.new(
+      name,
+      attributes,
+      children,
+      text,
+      name: name,
+    )
   end
 end

data/spec/lutaml/model/xml_adapter/xml_namespace_spec.rb

@@ -164,15 +164,15 @@ RSpec.describe "XmlNamespace" do
     end
 
     context "with no prefix" do
-      include_examples "XML serialization with namespace",
-                       TestModelNoPrefix,
-                       '<test xmlns="http://example.com/test"><name>Test Name</name></test>'
+      it_behaves_like "XML serialization with namespace",
+                      TestModelNoPrefix,
+                      '<test xmlns="http://example.com/test"><name>Test Name</name></test>'
     end
 
     context "with prefix" do
-      include_examples "XML serialization with namespace",
-                       TestModelWithPrefix,
-                       '<test:test xmlns:test="http://example.com/test"><test:name>Test Name</test:name></test:test>'
+      it_behaves_like "XML serialization with namespace",
+                      TestModelWithPrefix,
+                      '<test:test xmlns:test="http://example.com/test"><test:name>Test Name</test:name></test:test>'
     end
 
     context "with prefixed namespace" do

data/spec/lutaml/model/xml_adapter_spec.rb

@@ -130,6 +130,30 @@ RSpec.describe "XmlAdapter" do
       end
     end
 
+    context "when xml has `lang` attribute" do
+      before do
+        title_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :lang, :string
+          attribute :content, :string
+
+          xml do
+            root "title"
+
+            map_attribute "lang", to: :lang
+            map_content to: :content
+          end
+        end
+
+        stub_const("Title", title_class)
+      end
+
+      let(:xml_input) { "<title lang='en'>Title</title>" }
+      let(:parsed) { Title.from_xml(xml_input) }
+
+      it { expect(parsed.lang).to eq("en") }
+      it { expect(parsed.content).to eq("Title") }
+    end
+
     it "serializes to XML" do
       expected_xml = <<~XML
         <SampleModel>