lutaml-model 0.7.3 → 0.7.5

data/spec/lutaml/model/yamls/standard_adapter_spec.rb

@@ -0,0 +1,183 @@
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Yamls::StandardAdapter do
+  let(:valid_yamls_content) do
+    <<~YAMLS
+      name: John
+      age: 30
+      ---
+      name: Jane
+      age: 25
+      ---
+      name: Bob
+      age: 35
+    YAMLS
+  end
+
+  let(:invalid_yamls_content) do
+    <<~YAMLS
+      name: John
+      age: 30
+      ---
+      invalid yaml: [
+      ---
+      name: Bob
+      age: 35
+    YAMLS
+  end
+
+  describe ".parse" do
+    context "with valid YAMLS content" do
+      it "parses each YAML document as a separate object" do
+        results = described_class.parse(valid_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(3)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+        expect(results.last).to eq({ "name" => "Bob", "age" => 35 })
+      end
+    end
+
+    context "with invalid YAMLS content" do
+      it "skips invalid YAML documents and continues parsing" do
+        results = described_class.parse(invalid_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+        expect(results.last).to eq({ "name" => "Bob", "age" => 35 })
+      end
+    end
+
+    context "with empty documents" do
+      let(:yamls_with_empty_docs) do
+        <<~YAMLS
+          name: John
+          ---
+
+          ---
+          name: Jane
+        YAMLS
+      end
+
+      it "skips empty documents" do
+        results = described_class.parse(yamls_with_empty_docs)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+      end
+    end
+
+    context "with single document" do
+      let(:single_yaml_doc) do
+        <<~YAMLS
+          name: John
+          age: 30
+        YAMLS
+      end
+
+      it "parses single document correctly" do
+        results = described_class.parse(single_yaml_doc)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(1)
+        expect(results.first).to eq({ "name" => "John", "age" => 30 })
+      end
+    end
+
+    context "with complex YAML structures" do
+      let(:complex_yamls_content) do
+        <<~YAMLS
+          name: John
+          address:
+            street: 123 Main St
+            city: New York
+          hobbies:
+            - reading
+            - swimming
+          ---
+          name: Jane
+          address:
+            street: 456 Oak Ave
+            city: Los Angeles
+          hobbies:
+            - hiking
+            - cooking
+        YAMLS
+      end
+
+      it "parses complex YAML structures" do
+        results = described_class.parse(complex_yamls_content)
+        expect(results).to be_an(Array)
+        expect(results.length).to eq(2)
+
+        expect(results.first).to eq({
+                                      "name" => "John",
+                                      "address" => {
+                                        "street" => "123 Main St",
+                                        "city" => "New York",
+                                      },
+                                      "hobbies" => ["reading", "swimming"],
+                                    })
+
+        expect(results.last).to eq({
+                                     "name" => "Jane",
+                                     "address" => {
+                                       "street" => "456 Oak Ave",
+                                       "city" => "Los Angeles",
+                                     },
+                                     "hobbies" => ["hiking", "cooking"],
+                                   })
+      end
+    end
+  end
+
+  describe "#to_yamls" do
+    let(:john) { { "name" => "John", "age" => 30 } }
+    let(:adapter) { described_class.new([john]) }
+
+    it "generates YAMLS format" do
+      expect(adapter.to_yamls.strip).to eq(john.to_yaml.strip)
+    end
+
+    context "with multiple objects" do
+      let(:jane) { { "name" => "Jane", "age" => 25 } }
+      let(:adapter) { described_class.new([john, jane]) }
+
+      let(:expected_yamls) do
+        <<~YAMLS.strip
+          #{john.to_yaml.strip}
+          #{jane.to_yaml.strip}
+        YAMLS
+      end
+
+      it "generates multiple YAML documents" do
+        expect(adapter.to_yamls.strip).to eq(expected_yamls.strip)
+      end
+    end
+
+    context "with complex data structures" do
+      let(:adapter) do
+        described_class.new([
+                              {
+                                "name" => "John",
+                                "address" => {
+                                  "street" => "123 Main St",
+                                  "city" => "New York",
+                                },
+                                "hobbies" => ["reading", "swimming"],
+                              },
+                            ])
+      end
+
+      it "generates complex YAML structures" do
+        result = adapter.to_yamls
+        expect(result).to include("name")
+        expect(result).to include("address")
+        expect(result).to include("hobbies")
+      end
+    end
+  end
+
+  describe "FORMAT_SYMBOL" do
+    it "returns :yaml" do
+      expect(described_class::FORMAT_SYMBOL).to eq(:yaml)
+    end
+  end
+end

data/spec/lutaml/model/yamls_spec.rb

@@ -0,0 +1,294 @@
+require "spec_helper"
+
+module YamlsSpec
+  class Address < Lutaml::Model::Serializable
+    attribute :city, :string
+
+    yaml do
+      map "city", to: :city
+    end
+  end
+
+  class Person < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :age, :integer
+    attribute :address, Address
+
+    yaml do
+      map "full_name", to: :name
+      map "age", to: :age
+      map "address", to: :address
+    end
+  end
+
+  class Directory < Lutaml::Model::Collection
+    instances :persons, Person
+
+    yamls do
+      map_instances to: :persons
+    end
+  end
+end
+
+RSpec.describe "Yamls" do
+  let(:john) do
+    YamlsSpec::Person.new(
+      {
+        name: "John",
+        age: "30",
+        address: YamlsSpec::Address.new({ city: "New York" }),
+      },
+    )
+  end
+
+  let(:jane) do
+    YamlsSpec::Person.new(
+      {
+        name: "Jane",
+        age: "25",
+        address: YamlsSpec::Address.new({ city: "London" }),
+      },
+    )
+  end
+
+  let(:bob) do
+    YamlsSpec::Person.new(
+      {
+        name: "Bob",
+        age: "35",
+        address: YamlsSpec::Address.new({ city: "Paris" }),
+      },
+    )
+  end
+
+  let(:valid_yamls) do
+    <<~YAMLS.strip
+      ---
+      full_name: John
+      age: 30
+      address:
+        city: New York
+      ---
+      full_name: Jane
+      age: 25
+      address:
+        city: London
+      ---
+      full_name: Bob
+      age: 35
+      address:
+        city: Paris
+    YAMLS
+  end
+
+  let(:valid_yamls_with_empty_docs) do
+    <<~YAMLS
+      ---
+      full_name: John
+      age: 30
+      address:
+        city: New York
+      ---
+
+      ---
+      full_name: Jane
+      age: 25
+      address:
+        city: London
+      ---
+
+
+      ---
+      full_name: Bob
+      age: 35
+      address:
+        city: Paris
+      ---
+
+
+    YAMLS
+  end
+
+  let(:invalid_yamls_content) do
+    <<~YAMLS
+      ---
+      full_name: John
+      age: 30
+      address:
+        city: New York
+      ---
+      invalid yaml: [
+      ---
+      full_name: Bob
+      age: 35
+      address:
+        city: Paris
+    YAMLS
+  end
+
+  let(:parsed) { YamlsSpec::Directory.from_yamls(valid_yamls) }
+
+  it "parses all the yaml documents" do
+    expect(parsed.persons).to eq([john, jane, bob])
+  end
+
+  it "handles empty documents" do
+    expect(
+      YamlsSpec::Directory.from_yamls(valid_yamls_with_empty_docs).persons,
+    ).to eq([john, jane, bob])
+  end
+
+  it "round trips valid yamls correctly" do
+    expect(parsed.to_yamls).to eq(valid_yamls)
+  end
+
+  it "removes empty documents when round triping valid yamls" do
+    expect(
+      YamlsSpec::Directory.from_yamls(valid_yamls_with_empty_docs).to_yamls,
+    ).to eq(valid_yamls)
+  end
+
+  it "skips invalid documents and show warning" do
+    expect do
+      YamlsSpec::Directory.from_yamls(invalid_yamls_content)
+    end.to output(/Skipping invalid yaml: /).to_stderr
+  end
+
+  describe "parsing" do
+    it "handles empty documents" do
+      yamls_with_empty_docs = <<~YAMLS
+        ---
+        full_name: John
+        age: 30
+        address:
+          city: New York
+        ---
+
+        ---
+        full_name: Jane
+        age: 25
+        address:
+          city: London
+      YAMLS
+      result = YamlsSpec::Directory.from_yamls(yamls_with_empty_docs)
+      expect(result.persons).to be_an(Array)
+      expect(result.persons.length).to eq(2)
+    end
+  end
+
+  describe "roundtrip" do
+    it "maintains data integrity with special characters" do
+      special_chars_yamls = <<~YAMLS
+        ---
+        full_name: John Doe
+        age: 30
+        address:
+          city: New York
+        ---
+        full_name: Jane "Smith"
+        age: 25
+        address:
+          city: London
+      YAMLS
+
+      # Parse the original YAMLS
+      directory = YamlsSpec::Directory.from_yamls(special_chars_yamls)
+
+      # Serialize back to YAMLS
+      serialized = directory.to_yamls
+
+      # Parse the serialized data again
+      roundtrip_directory = YamlsSpec::Directory.from_yamls(serialized)
+
+      # Compare the results
+      expect(roundtrip_directory.persons.length).to eq(directory.persons.length)
+      roundtrip_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+  end
+
+  describe "format conversion" do
+    let(:valid_yamls_content) do
+      <<~YAMLS.strip
+        ---
+        full_name: John
+        age: 30
+        address:
+          city: New York
+        ---
+        full_name: Jane
+        age: 25
+        address:
+          city: London
+        ---
+        full_name: Bob
+        age: 35
+        address:
+          city: Paris
+      YAMLS
+    end
+
+    it "converts between YAMLS and YAML" do
+      # Parse YAMLS to Directory
+      directory = YamlsSpec::Directory.from_yamls(valid_yamls_content)
+
+      # Convert to YAML
+      yaml_string = directory.to_yaml
+
+      # Parse YAML back to Directory
+      yaml_directory = YamlsSpec::Directory.from_yaml(yaml_string)
+
+      # Convert back to YAMLS
+      yamls_output = yaml_directory.to_yamls
+
+      # Final parse to verify
+      final_directory = YamlsSpec::Directory.from_yamls(yamls_output)
+
+      # Compare the results
+      expect(final_directory.persons.length).to eq(directory.persons.length)
+      final_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+
+    it "handles collections of objects" do
+      # Create a directory with people
+      directory = YamlsSpec::Directory.new(
+        [
+          YamlsSpec::Person.new(
+            name: "John",
+            age: 30,
+            address: YamlsSpec::Address.new(city: "New York"),
+          ),
+          YamlsSpec::Person.new(
+            name: "Jane",
+            age: 25,
+            address: YamlsSpec::Address.new(city: "London"),
+          ),
+        ],
+      )
+
+      # Convert to YAMLS
+      yamls_output = directory.to_yamls
+
+      # Parse back to verify
+      parsed_directory = YamlsSpec::Directory.from_yamls(yamls_output)
+
+      # Compare the results
+      expect(parsed_directory.persons.length).to eq(directory.persons.length)
+      parsed_directory.persons.each_with_index do |person, index|
+        original = directory.persons[index]
+        expect(person.name).to eq(original.name)
+        expect(person.age).to eq(original.age)
+        expect(person.address.city).to eq(original.address.city)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -28,6 +28,7 @@ require_relative "../lib/lutaml/model"
 
 Lutaml::Model::Config.configure do |config|
   config.xml_adapter_type = :nokogiri
+  config.hash_adapter_type = :standard_hash
   config.json_adapter_type = :standard_json
   config.yaml_adapter_type = :standard_yaml
   config.toml_adapter_type = :toml_rb