lutaml-model 0.7.3 → 0.7.5

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/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>

data/spec/lutaml/model/xml_mapping_rule_spec.rb

@@ -19,12 +19,19 @@ RSpec.describe Lutaml::Model::Xml::MappingRule do
     end
 
     context "when attribute name is string 'lang'" do
-      let(:mapping_rule) do
-        described_class.new("lang", to: :lang, prefix: "xml")
+      it "returns `xml:lang` when prefix is set" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: "xml")
+        expect(mapping_rule.namespaced_name).to eq("xml:lang")
       end
 
-      it "returns `xml:lang`" do
-        expect(namespaced_name).to eq("xml:lang")
+      it "returns `lang` when prefix is empty string" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: "")
+        expect(mapping_rule.namespaced_name).to eq("lang")
+      end
+
+      it "returns `lang` when prefix is nil" do
+        mapping_rule = described_class.new("lang", to: :lang, prefix: nil)
+        expect(mapping_rule.namespaced_name).to eq("lang")
       end
     end
 

data/spec/lutaml/model/xml_mapping_spec.rb

@@ -732,7 +732,7 @@ RSpec.describe Lutaml::Model::Xml::Mapping do
         end
 
         it "prints warning if defined explicitly in class" do
-          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explecitly define at `xml_mapping_spec.rb:\d+`/
+          error_regex = /\[Lutaml::Model\] WARN: `schemaLocation` is handled by default\. No need to explicitly define at `xml_mapping_spec.rb:\d+`/
 
           expect do
             mapping.map_attribute("schemaLocation", to: :schema_location)