lutaml-store 0.2.0 → 0.2.1

data/spec/lutaml/store/database_store_spec.rb

@@ -1,279 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-module DatabaseStoreTestModels
-  class TestStudio < Lutaml::Model::Serializable
-    attribute :studio_key, :string
-    attribute :name, :string
-    attribute :location, :string
-    attribute :_class, :string, default: -> { "TestStudio" }, polymorphic_class: true
-  end
-
-  class TestCeramicStudio < TestStudio
-    attribute :clay_type, :string
-    attribute :_class, :string, default: -> { "TestCeramicStudio" }
-  end
-
-  class TestPotteryClass < Lutaml::Model::Serializable
-    attribute :class_id, :string
-    attribute :description, :string
-    attribute :studio, TestStudio, polymorphic: true
-  end
-end
-
-RSpec.describe Lutaml::Store::DatabaseStore do
-  let(:config) { { adapter_type: :memory } }
-
-  let(:models) do
-    [
-      { model: DatabaseStoreTestModels::TestPotteryClass, key: :class_id },
-      { model: DatabaseStoreTestModels::TestStudio, key: :studio_key, polymorphic_class_key: :_class },
-      { model: DatabaseStoreTestModels::TestCeramicStudio, key: :studio_key, polymorphic_class_key: :_class }
-    ]
-  end
-
-  let(:store) { described_class.new(adapter: :memory, models: models) }
-
-  describe "#initialize" do
-    it "creates a database store with models" do
-      expect(store).to be_a(described_class)
-      expect(store.registry.count).to eq(3)
-    end
-
-    it "raises error when no models provided" do
-      expect do
-        described_class.new(adapter: :memory, models: [])
-      end.to raise_error(Lutaml::Store::ConfigurationError, /No models registered/)
-    end
-  end
-
-  describe "#save and #fetch" do
-    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
-    let(:pottery_class) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio
-      )
-    end
-
-    it "saves and fetches a model with composite relationships" do
-      store.save(pottery_class)
-
-      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
-      expect(fetched).to be_a(DatabaseStoreTestModels::TestPotteryClass)
-      expect(fetched.class_id).to eq("pottery_101")
-      expect(fetched.description).to eq("Basic pottery")
-      expect(fetched.studio).to be_a(DatabaseStoreTestModels::TestStudio)
-      expect(fetched.studio.studio_key).to eq("test_studio")
-      expect(fetched.studio.name).to eq("Test Studio")
-    end
-
-    it "handles polymorphic models correctly" do
-      ceramic_studio = DatabaseStoreTestModels::TestCeramicStudio.new(
-        studio_key: "ceramic_studio",
-        name: "Ceramic Studio",
-        clay_type: "Porcelain"
-      )
-
-      store.save(ceramic_studio)
-
-      fetched = store.fetch(model: DatabaseStoreTestModels::TestStudio, studio_key: "ceramic_studio")
-      expect(fetched).to be_a(DatabaseStoreTestModels::TestCeramicStudio)
-      expect(fetched.clay_type).to eq("Porcelain")
-    end
-
-    it "returns nil for non-existent models" do
-      result = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")
-      expect(result).to be_nil
-    end
-  end
-
-  describe "#update" do
-    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
-    let(:pottery_class) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio
-      )
-    end
-
-    before { store.save(pottery_class) }
-
-    it "updates with block" do
-      updated = store.update(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101") do |model|
-        model.description = "Advanced pottery"
-        model
-      end
-
-      expect(updated.description).to eq("Advanced pottery")
-
-      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
-      expect(fetched.description).to eq("Advanced pottery")
-    end
-
-    it "updates with hash including dot notation" do
-      updated = store.update(
-        model: DatabaseStoreTestModels::TestPotteryClass,
-        class_id: "pottery_101",
-        attributes: { "studio.location" => "Downtown" }
-      )
-
-      expect(updated.studio.location).to eq("Downtown")
-
-      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
-      expect(fetched.studio.location).to eq("Downtown")
-    end
-  end
-
-  describe "#destroy" do
-    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
-    let(:pottery_class) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio
-      )
-    end
-
-    before { store.save(pottery_class) }
-
-    it "destroys a model and its composite relationships" do
-      result = store.destroy(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
-      expect(result).to be true
-
-      fetched = store.fetch(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")
-      expect(fetched).to be_nil
-
-      studio_fetched = store.fetch(model: DatabaseStoreTestModels::TestStudio, studio_key: "test_studio")
-      expect(studio_fetched).to be_nil
-    end
-
-    it "returns false for non-existent models" do
-      result = store.destroy(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")
-      expect(result).to be false
-    end
-  end
-
-  describe "#where" do
-    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
-    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
-    let(:pottery1) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio1
-      )
-    end
-    let(:pottery2) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_201",
-        description: "Advanced pottery",
-        studio: studio2
-      )
-    end
-
-    before do
-      store.save([pottery1, pottery2])
-    end
-
-    it "finds models by criteria" do
-      results = store.where(model: DatabaseStoreTestModels::TestPotteryClass, description: "Basic pottery")
-      expect(results.size).to eq(1)
-      expect(results.first.class_id).to eq("pottery_101")
-    end
-  end
-
-  describe "#all" do
-    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
-    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
-    let(:pottery1) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio1
-      )
-    end
-    let(:pottery2) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_201",
-        description: "Advanced pottery",
-        studio: studio2
-      )
-    end
-
-    before do
-      store.save([pottery1, pottery2])
-    end
-
-    it "returns all models of a specific type" do
-      results = store.all(model: DatabaseStoreTestModels::TestPotteryClass)
-      expect(results.size).to eq(2)
-      expect(results.map(&:class_id)).to contain_exactly("pottery_101", "pottery_201")
-    end
-  end
-
-  describe "#exists?" do
-    let(:studio) { DatabaseStoreTestModels::TestStudio.new(studio_key: "test_studio", name: "Test Studio") }
-    let(:pottery_class) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio
-      )
-    end
-
-    before { store.save(pottery_class) }
-
-    it "returns true for existing models" do
-      expect(store.exists?(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "pottery_101")).to be true
-    end
-
-    it "returns false for non-existent models" do
-      expect(store.exists?(model: DatabaseStoreTestModels::TestPotteryClass, class_id: "nonexistent")).to be false
-    end
-  end
-
-  describe "#count" do
-    let(:studio1) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio1", name: "Studio One") }
-    let(:studio2) { DatabaseStoreTestModels::TestStudio.new(studio_key: "studio2", name: "Studio Two") }
-    let(:pottery1) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_101",
-        description: "Basic pottery",
-        studio: studio1
-      )
-    end
-    let(:pottery2) do
-      DatabaseStoreTestModels::TestPotteryClass.new(
-        class_id: "pottery_201",
-        description: "Advanced pottery",
-        studio: studio2
-      )
-    end
-
-    before do
-      store.save([pottery1, pottery2])
-    end
-
-    it "returns count of models" do
-      expect(store.count(model: DatabaseStoreTestModels::TestPotteryClass)).to eq(2)
-      expect(store.count(model: DatabaseStoreTestModels::TestStudio)).to eq(2)
-    end
-  end
-
-  describe "#stats" do
-    it "provides statistics" do
-      stats = store.stats
-      expect(stats).to include(:models_registered, :registered_models, :total_models)
-      expect(stats[:models_registered]).to eq(3)
-      expect(stats[:registered_models]).to include(
-        "DatabaseStoreTestModels::TestPotteryClass",
-        "DatabaseStoreTestModels::TestStudio",
-        "DatabaseStoreTestModels::TestCeramicStudio"
-      )
-    end
-  end
-end

data/spec/lutaml/store/file_io_spec.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "tmpdir"
-require "json"
-
-class FileTestItem < Lutaml::Model::Serializable
-  attribute :name, :string
-  attribute :value, :string
-
-  key_value do
-    map :name, to: :name
-    map :value, to: :value
-  end
-end
-
-RSpec.describe "Lutaml::Store file I/O" do
-  let(:tmpdir) { Dir.mktmpdir }
-  after { FileUtils.rm_rf(tmpdir) }
-
-  let(:store) do
-    Lutaml::Store.new(
-      adapter: :memory,
-      models: [{ model: FileTestItem, key: :name, dir: "items" }]
-    )
-  end
-
-  let(:items) do
-    [
-      FileTestItem.new(name: "alpha", value: "first"),
-      FileTestItem.new(name: "beta", value: "second"),
-      FileTestItem.new(name: "gamma", value: "third")
-    ]
-  end
-
-  def items_dir
-    File.join(tmpdir, "items")
-  end
-
-  # ── YAML format ──
-
-  describe "YAML separate layout" do
-    it "round-trips models" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
-
-      expect(Dir.glob(File.join(items_dir, "*.{yaml,yml}")).size).to eq(3)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :separate)
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-      expect(loaded.map(&:value).sort).to eq(%w[first second third])
-    end
-
-    it "writes one file per model named by key" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
-
-      expect(File.exist?(File.join(items_dir, "alpha.yaml"))).to be true
-      expect(File.exist?(File.join(items_dir, "beta.yaml"))).to be true
-      expect(File.exist?(File.join(items_dir, "gamma.yaml"))).to be true
-    end
-  end
-
-  describe "YAML grouped layout" do
-    it "writes one file per key" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
-
-      files = Dir.glob(File.join(items_dir, "*.yaml")).sort
-      expect(files.size).to eq(3)
-    end
-
-    it "round-trips models" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :grouped)
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-    end
-  end
-
-  # ── JSON format ──
-
-  describe "JSON separate layout" do
-    it "round-trips models" do
-      store.save_all(items, path: tmpdir, format: :json, layout: :separate)
-
-      expect(Dir.glob(File.join(items_dir, "*.json")).size).to eq(3)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :json, layout: :separate)
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-    end
-
-    it "writes valid JSON files" do
-      store.save_all(items, path: tmpdir, format: :json, layout: :separate)
-
-      Dir.glob(File.join(items_dir, "*.json")).each do |path|
-        expect { JSON.parse(File.read(path, encoding: "utf-8")) }.not_to raise_error
-      end
-    end
-  end
-
-  # ── JSONL format ──
-
-  describe "JSONL export/import" do
-    it "exports models to JSONL file" do
-      export_path = File.join(tmpdir, "data.jsonl")
-      store.export(items, path: export_path, format: :jsonl)
-
-      expect(File.exist?(export_path)).to be true
-      lines = File.read(export_path, encoding: "utf-8").lines.reject { |l| l.strip.empty? }
-      expect(lines.size).to eq(3)
-      lines.each { |line| expect { JSON.parse(line) }.not_to raise_error }
-    end
-
-    it "round-trips through JSONL file" do
-      export_path = File.join(tmpdir, "data.jsonl")
-      store.export(items, path: export_path, format: :jsonl)
-
-      fmt = Lutaml::Store::Format.resolve(:jsonl)
-      data = File.read(export_path, encoding: "utf-8")
-      loaded = fmt.deserialize_many(data, FileTestItem)
-
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-    end
-  end
-
-  # ── Marshal format ──
-
-  describe "Marshal separate layout" do
-    it "round-trips models" do
-      store.save_all(items, path: tmpdir, format: :marshal, layout: :separate)
-
-      expect(Dir.glob(File.join(items_dir, "*.bin")).size).to eq(3)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :marshal, layout: :separate)
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-    end
-  end
-
-  # ── YAMLS format ──
-  # Format::Yamls requires models with the yamls DSL (e.g. ConceptDocument).
-  # For simple models without yamls DSL, use Format::Yaml (:yaml) instead.
-
-  describe "YAML multi-document via grouped layout" do
-    it "writes multi-document YAML files" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
-
-      files = Dir.glob(File.join(items_dir, "*.{yaml,yml}")).sort
-      expect(files.size).to eq(3)
-    end
-
-    it "round-trips models" do
-      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :grouped)
-      expect(loaded.size).to eq(3)
-      expect(loaded.map(&:name).sort).to eq(%w[alpha beta gamma])
-    end
-  end
-
-  # ── Edge cases ──
-
-  describe "empty directory" do
-    it "returns empty array from load_all" do
-      FileUtils.mkdir_p(items_dir)
-
-      loaded = store.load_all(FileTestItem, path: tmpdir, format: :yaml, layout: :separate)
-      expect(loaded).to eq([])
-    end
-  end
-
-  describe "empty model list" do
-    it "returns empty array from save_all" do
-      result = store.save_all([], path: tmpdir, format: :yaml, layout: :separate)
-      expect(result).to eq([])
-    end
-  end
-
-  describe "missing directory" do
-    it "raises BackendError for load_all" do
-      expect do
-        store.load_all(FileTestItem, path: "/nonexistent/path", format: :yaml, layout: :separate)
-      end.to raise_error(Lutaml::Store::BackendError, /Directory not found/)
-    end
-  end
-
-  describe "no path provided" do
-    it "raises BackendError for save_all without path" do
-      items_with_no_dir = [
-        FileTestItem.new(name: "x", value: "y")
-      ]
-      # No dir in registration and no path
-      bare_store = Lutaml::Store.new(
-        adapter: :memory,
-        models: [{ model: FileTestItem, key: :name }]
-      )
-      expect do
-        bare_store.save_all(items_with_no_dir, format: :yaml, layout: :separate)
-      end.to raise_error(Lutaml::Store::BackendError, /No directory specified/)
-    end
-  end
-
-  describe "unknown layout" do
-    it "raises ConfigurationError" do
-      expect do
-        store.save_all(items, path: tmpdir, format: :yaml, layout: :unknown)
-      end.to raise_error(Lutaml::Store::ConfigurationError, /Unknown layout/)
-    end
-  end
-
-  describe "unknown format" do
-    it "raises UnsupportedFormatError" do
-      expect do
-        store.save_all(items, path: tmpdir, format: :csv, layout: :separate)
-      end.to raise_error(Lutaml::Store::Format::UnsupportedFormatError)
-    end
-  end
-end

data/spec/lutaml/store/format/yamls_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "support/yamls_test_model"
-
-RSpec.describe Lutaml::Store::Format::Yamls do
-  let(:fmt) { described_class.new }
-
-  let(:model) do
-    YamlsTestModel.new(
-      header: YamlsTestHeader.new(id: "test-1", name: "Test"),
-      parts: [
-        YamlsTestPart.new(label: "a", value: "1"),
-        YamlsTestPart.new(label: "b", value: "2")
-      ]
-    )
-  end
-
-  describe "#extension" do
-    it { expect(fmt.extension).to eq(".yaml") }
-  end
-
-  describe "#glob_pattern" do
-    it { expect(fmt.glob_pattern).to eq("*.{yaml,yml}") }
-  end
-
-  describe "#serialize" do
-    it "produces a YAML stream starting with ---" do
-      result = fmt.serialize(model)
-      expect(result).to start_with("---")
-    end
-
-    it "produces multiple --- separators for multi-part models" do
-      result = fmt.serialize(model)
-      separators = result.scan(/^---$/).length
-      expect(separators).to be >= 2
-    end
-  end
-
-  describe "#deserialize" do
-    it "reconstructs the model from a YAML stream" do
-      yaml = fmt.serialize(model)
-      loaded = fmt.deserialize(yaml, YamlsTestModel)
-
-      expect(loaded.header.id).to eq("test-1")
-      expect(loaded.header.name).to eq("Test")
-    end
-  end
-
-  describe "round-trip" do
-    it "preserves model data including parts" do
-      yaml = fmt.serialize(model)
-      loaded = fmt.deserialize(yaml, YamlsTestModel)
-
-      expect(loaded.header.id).to eq("test-1")
-      expect(loaded.header.name).to eq("Test")
-      expect(loaded.parts.length).to eq(2)
-      expect(loaded.parts.first.label).to eq("a")
-      expect(loaded.parts.last.value).to eq("2")
-    end
-  end
-
-  describe "#serialize_many" do
-    it "serializes a single model identically to #serialize" do
-      # In GCR, each file has exactly one concept (one group per key).
-      # serialize_many([single]) == serialize(single).
-      result = fmt.serialize_many([model])
-      expect(result).to eq(fmt.serialize(model))
-    end
-  end
-
-  describe "#deserialize_many" do
-    it "returns an array from a YAML stream" do
-      yaml = fmt.serialize(model)
-      result = fmt.deserialize_many(yaml, YamlsTestModel)
-      expect(result).to be_an(Array)
-      expect(result.first).to be_a(YamlsTestModel)
-    end
-  end
-end

data/spec/lutaml/store/format_round_trip_spec.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "json"
-
-class FormatTestItem < Lutaml::Model::Serializable
-  attribute :name, :string
-  attribute :value, :string
-  attribute :count, :integer
-
-  key_value do
-    map :name, to: :name
-    map :value, to: :value
-    map :count, to: :count
-  end
-end
-
-RSpec.describe "Format handler round-trips" do
-  let(:item) { FormatTestItem.new(name: "alpha", value: "first", count: 42) }
-  let(:items) do
-    [
-      FormatTestItem.new(name: "alpha", value: "first", count: 1),
-      FormatTestItem.new(name: "beta", value: "second", count: 2)
-    ]
-  end
-
-  shared_examples "single-model round-trip" do |format_sym|
-    it "round-trips a single model through #{format_sym}" do
-      fmt = Lutaml::Store::Format.resolve(format_sym)
-      serialized = fmt.serialize(item)
-      restored = fmt.deserialize(serialized, FormatTestItem)
-
-      expect(restored.name).to eq("alpha")
-      expect(restored.value).to eq("first")
-      expect(restored.count).to eq(42)
-    end
-  end
-
-  shared_examples "multi-model round-trip" do |format_sym|
-    it "round-trips multiple models through #{format_sym}" do
-      fmt = Lutaml::Store::Format.resolve(format_sym)
-      serialized = fmt.serialize_many(items)
-      restored = fmt.deserialize_many(serialized, FormatTestItem)
-
-      expect(restored.size).to eq(2)
-      expect(restored.map(&:name).sort).to eq(%w[alpha beta])
-      expect(restored.map(&:count).sort).to eq([1, 2])
-    end
-  end
-
-  describe Lutaml::Store::Format::Yaml do
-    it_behaves_like "single-model round-trip", :yaml
-    it_behaves_like "multi-model round-trip", :yaml
-
-    it "produces valid YAML" do
-      fmt = described_class.new
-      output = fmt.serialize(item)
-      expect(output).to include("name:")
-      expect(output).to include("value:")
-    end
-  end
-
-  describe Lutaml::Store::Format::Yamls do
-    # Format::Yamls requires models with the yamls DSL (multi-document YAML stream).
-    # Tested separately in spec/lutaml/store/format/yamls_spec.rb with proper yamls models.
-
-    it "produces multi-document YAML stream" do
-      fmt = described_class.new
-      output = fmt.serialize_many(items)
-      expect(output.scan(/^---/).size).to be >= 2
-    end
-  end
-
-  describe Lutaml::Store::Format::Json do
-    it_behaves_like "single-model round-trip", :json
-
-    it "produces valid JSON" do
-      fmt = described_class.new
-      output = fmt.serialize(item)
-      parsed = JSON.parse(output)
-      expect(parsed["name"]).to eq("alpha")
-      expect(parsed["count"]).to eq(42)
-    end
-  end
-
-  describe Lutaml::Store::Format::Jsonl do
-    it_behaves_like "single-model round-trip", :jsonl
-    it_behaves_like "multi-model round-trip", :jsonl
-
-    it "produces line-delimited JSON" do
-      fmt = described_class.new
-      output = fmt.serialize_many(items)
-      lines = output.lines.reject { |l| l.strip.empty? }
-      expect(lines.size).to eq(2)
-      lines.each { |line| expect { JSON.parse(line) }.not_to raise_error }
-    end
-  end
-
-  describe Lutaml::Store::Format::MarshalFormat do
-    it_behaves_like "single-model round-trip", :marshal
-    it_behaves_like "multi-model round-trip", :marshal
-
-    it "produces binary data" do
-      fmt = described_class.new
-      output = fmt.serialize(item)
-      expect(output).to be_a(String)
-      expect(output.encoding).to eq(Encoding::ASCII_8BIT)
-    end
-  end
-end