lutaml-store 0.1.1 → 0.2.0

data/spec/lutaml/store/package_definition_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/simple_test_model"
+require "support/yamls_test_model"
+
+RSpec.describe Lutaml::Store::PackageDefinition do
+  subject(:definition) do
+    described_class.new(
+      name: :test,
+      metadata_model: SimpleTestModel,
+      metadata_file: "meta.yaml"
+    ) do |pkg|
+      pkg.model(model: YamlsTestModel, dir: "items",
+                layout: :separate, key: :id, default_format: :yamls)
+      pkg.model(model: SimpleTestModel, file: "config.yaml",
+                key: :id, default_format: :yaml)
+      pkg.asset("images", type: :directory)
+      pkg.asset("readme.txt", type: :file)
+    end
+  end
+
+  it "stores name" do
+    expect(definition.name).to eq(:test)
+  end
+
+  it "stores metadata model and file" do
+    expect(definition.metadata_model).to eq(SimpleTestModel)
+    expect(definition.metadata_file).to eq("meta.yaml")
+  end
+
+  it "stores model entries" do
+    expect(definition.model_entries.length).to eq(2)
+
+    yamls_entry = definition.model_entries.first
+    expect(yamls_entry.model).to eq(YamlsTestModel)
+    expect(yamls_entry.dir).to eq("items")
+    expect(yamls_entry.layout).to eq(:separate)
+    expect(yamls_entry.key).to eq(:id)
+    expect(yamls_entry.default_format).to eq(:yamls)
+
+    simple_entry = definition.model_entries.last
+    expect(simple_entry.model).to eq(SimpleTestModel)
+    expect(simple_entry.file).to eq("config.yaml")
+  end
+
+  it "stores asset entries" do
+    expect(definition.asset_entries.length).to eq(2)
+    expect(definition.asset_entries[0].path).to eq("images")
+    expect(definition.asset_entries[0].type).to eq(:directory)
+    expect(definition.asset_entries[1].path).to eq("readme.txt")
+    expect(definition.asset_entries[1].type).to eq(:file)
+  end
+
+  describe "dir/file mutual exclusivity" do
+    it "raises when both dir and file are specified" do
+      expect do
+        definition.model(model: SimpleTestModel, dir: "d", file: "f.yaml", key: :id)
+      end.to raise_error(ArgumentError, /Specify dir: or file:, not both/)
+    end
+  end
+
+  describe "#entry_for" do
+    it "finds entry by model class" do
+      entry = definition.entry_for(YamlsTestModel)
+      expect(entry).not_to be_nil
+      expect(entry.dir).to eq("items")
+    end
+
+    it "returns nil for unknown model" do
+      expect(definition.entry_for(String)).to be_nil
+    end
+  end
+
+  describe "#model_classes" do
+    it "returns registered model classes" do
+      expect(definition.model_classes).to contain_exactly(YamlsTestModel, SimpleTestModel)
+    end
+  end
+
+  describe "#database_store_models" do
+    it "includes model entries only (metadata is stored separately)" do
+      configs = definition.database_store_models
+      expect(configs.length).to eq(2) # 2 model entries, no metadata
+      models = configs.map { |c| c[:model] }
+      expect(models).to contain_exactly(YamlsTestModel, SimpleTestModel)
+    end
+  end
+end

data/spec/lutaml/store/package_store_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/simple_test_model"
+require "support/yamls_test_model"
+
+RSpec.describe Lutaml::Store::PackageStore do
+  let(:definition) do
+    Lutaml::Store::PackageDefinition.new(name: :test) do |pkg|
+      pkg.model(model: SimpleTestModel, dir: "items",
+                layout: :separate, key: :id, default_format: :yaml)
+    end
+  end
+
+  let(:store) { described_class.new(definition) }
+
+  describe "#add_model / #models_for" do
+    it "stores and retrieves model instances" do
+      model = SimpleTestModel.new(id: "test-1", name: "Test")
+      store.add_model(model)
+      expect(store.models_for(SimpleTestModel)).to include(model)
+    end
+
+    it "stores multiple instances" do
+      3.times { |i| store.add_model(SimpleTestModel.new(id: "test-#{i}")) }
+      expect(store.model_count(SimpleTestModel)).to eq(3)
+    end
+  end
+
+  describe "#fetch_model" do
+    it "retrieves by key" do
+      model = SimpleTestModel.new(id: "abc", name: "ABC")
+      store.add_model(model)
+      expect(store.fetch_model(SimpleTestModel, "abc").name).to eq("ABC")
+    end
+
+    it "returns nil for missing key" do
+      expect(store.fetch_model(SimpleTestModel, "missing")).to be_nil
+    end
+  end
+
+  describe "#model_exists?" do
+    it "returns true for existing key" do
+      store.add_model(SimpleTestModel.new(id: "exists"))
+      expect(store.model_exists?(SimpleTestModel, "exists")).to be true
+    end
+
+    it "returns false for missing key" do
+      expect(store.model_exists?(SimpleTestModel, "missing")).to be false
+    end
+  end
+
+  describe "#remove_model" do
+    it "removes by key" do
+      store.add_model(SimpleTestModel.new(id: "remove-me"))
+      store.remove_model(SimpleTestModel, "remove-me")
+      expect(store.model_exists?(SimpleTestModel, "remove-me")).to be false
+    end
+  end
+
+  describe "#metadata=" do
+    let(:def_with_metadata) do
+      Lutaml::Store::PackageDefinition.new(
+        name: :test, metadata_model: SimpleTestModel,
+        metadata_file: "meta.yaml", metadata_key: :id
+      ) do |pkg|
+        pkg.model(model: SimpleTestModel, dir: "items",
+                  layout: :separate, key: :id, default_format: :yaml)
+      end
+    end
+
+    it "stores metadata" do
+      store = described_class.new(def_with_metadata)
+      store.metadata = SimpleTestModel.new(id: "meta", name: "Metadata")
+      expect(store.metadata.name).to eq("Metadata")
+    end
+  end
+
+  describe "#add_asset / #asset" do
+    it "stores and retrieves raw content" do
+      store.add_asset("images/logo.png", "PNG_DATA")
+      expect(store.asset("images/logo.png")).to eq("PNG_DATA")
+    end
+
+    it "lists asset paths" do
+      store.add_asset("a.txt", "A")
+      store.add_asset("b.txt", "B")
+      expect(store.asset_paths).to contain_exactly("a.txt", "b.txt")
+    end
+  end
+
+  describe "#remove_asset" do
+    it "removes an asset" do
+      store.add_asset("remove.txt", "data")
+      store.remove_asset("remove.txt")
+      expect(store.asset("remove.txt")).to be_nil
+    end
+  end
+
+  describe "#clear_all" do
+    it "removes everything" do
+      store.add_model(SimpleTestModel.new(id: "x"))
+      store.add_asset("file.txt", "data")
+      store.clear_all
+      expect(store.model_count(SimpleTestModel)).to eq(0)
+      expect(store.asset_paths).to be_empty
+    end
+  end
+
+  describe "#stats" do
+    it "reports model counts and asset count" do
+      store.add_model(SimpleTestModel.new(id: "1"))
+      store.add_asset("f.txt", "x")
+      stats = store.stats
+      expect(stats[:package]).to eq(:test)
+      expect(stats[:models][SimpleTestModel.name]).to eq(1)
+      expect(stats[:assets]).to eq(1)
+    end
+  end
+
+  describe "#resolve_formats" do
+    let(:def_with_two) do
+      Lutaml::Store::PackageDefinition.new(name: :test) do |pkg|
+        pkg.model(model: SimpleTestModel, dir: "a", key: :id, default_format: :yaml)
+        pkg.model(model: SimpleTestModel, dir: "b", key: :id, default_format: :yamls)
+      end
+    end
+
+    let(:two_model_store) { described_class.new(def_with_two) }
+
+    it "global format overrides all models" do
+      formats = two_model_store.send(:resolve_formats, :json, {})
+      expect(formats[SimpleTestModel]).to eq(:json)
+    end
+
+    it "per-model format overrides specific models" do
+      formats = two_model_store.send(:resolve_formats, nil,
+                                     { SimpleTestModel => :marshal })
+      expect(formats[SimpleTestModel]).to eq(:marshal)
+    end
+
+    it "both: global + per-model merge" do
+      formats = two_model_store.send(:resolve_formats, :json,
+                                     { SimpleTestModel => :marshal })
+      expect(formats[SimpleTestModel]).to eq(:marshal)
+    end
+
+    it "nil: use defaults (empty hash)" do
+      formats = two_model_store.send(:resolve_formats, nil, {})
+      expect(formats).to be_empty
+    end
+  end
+end

data/spec/lutaml/store/package_transport/directory_transport_spec.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/simple_test_model"
+
+RSpec.describe Lutaml::Store::PackageTransport::DirectoryTransport do
+  let(:transport) { described_class.new }
+  let(:tmpdir) { Dir.mktmpdir }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  let(:definition) do
+    Lutaml::Store::PackageDefinition.new(
+      name: :test, metadata_model: SimpleTestModel,
+      metadata_file: "meta.yaml", metadata_key: :id
+    ) do |pkg|
+      pkg.model(model: SimpleTestModel, dir: "items",
+                layout: :separate, key: :id, default_format: :yaml)
+      pkg.asset("data.bin", type: :file)
+      pkg.asset("images", type: :directory)
+    end
+  end
+
+  describe "round-trip: write then read" do
+    it "preserves models, metadata, and assets" do
+      store = Lutaml::Store::PackageStore.new(definition)
+      store.add_model(SimpleTestModel.new(id: "item-1", name: "First"))
+      store.add_model(SimpleTestModel.new(id: "item-2", name: "Second"))
+      store.metadata = SimpleTestModel.new(id: "meta", name: "Test Package")
+      store.add_asset("data.bin", "BINARY_CONTENT")
+      store.add_asset("images/logo.png", "PNG_BYTES")
+
+      output_dir = File.join(tmpdir, "output")
+      store.save(output_dir, transport: :directory)
+
+      # Verify file structure
+      expect(File.exist?(File.join(output_dir, "meta.yaml"))).to be true
+      expect(File.exist?(File.join(output_dir, "items", "item-1.yaml"))).to be true
+      expect(File.exist?(File.join(output_dir, "items", "item-2.yaml"))).to be true
+      expect(File.exist?(File.join(output_dir, "data.bin"))).to be true
+      expect(File.exist?(File.join(output_dir, "images", "logo.png"))).to be true
+
+      # Load back
+      loaded = Lutaml::Store::PackageStore.load(definition, output_dir,
+                                                transport: :directory)
+      expect(loaded.model_count(SimpleTestModel)).to eq(2)
+      expect(loaded.metadata.name).to eq("Test Package")
+      expect(loaded.asset("data.bin")).to eq("BINARY_CONTENT")
+      expect(loaded.asset("images/logo.png")).to eq("PNG_BYTES")
+    end
+  end
+
+  describe "missing optional entries" do
+    it "loads successfully with empty directory" do
+      empty_dir = File.join(tmpdir, "empty")
+      FileUtils.mkdir_p(File.join(empty_dir, "items"))
+      loaded = Lutaml::Store::PackageStore.load(definition, empty_dir,
+                                                transport: :directory)
+      expect(loaded.model_count(SimpleTestModel)).to eq(0)
+      expect(loaded.metadata).to be_nil
+    end
+  end
+
+  describe "format override" do
+    it "writes models in JSON format when overridden" do
+      store = Lutaml::Store::PackageStore.new(definition)
+      store.add_model(SimpleTestModel.new(id: "item-1", name: "First"))
+
+      output_dir = File.join(tmpdir, "json")
+      store.save(output_dir, transport: :directory,
+                             formats: { SimpleTestModel => :json })
+
+      files = Dir.glob(File.join(output_dir, "items", "*"))
+      expect(files.length).to eq(1)
+      expect(File.extname(files.first)).to eq(".json")
+    end
+
+    it "loads models saved in JSON format" do
+      store = Lutaml::Store::PackageStore.new(definition)
+      store.add_model(SimpleTestModel.new(id: "item-1", name: "First"))
+
+      output_dir = File.join(tmpdir, "json")
+      store.save(output_dir, transport: :directory,
+                             formats: { SimpleTestModel => :json })
+
+      loaded = Lutaml::Store::PackageStore.load(definition, output_dir,
+                                                transport: :directory,
+                                                format: :json)
+      expect(loaded.model_count(SimpleTestModel)).to eq(1)
+      expect(loaded.fetch_model(SimpleTestModel, "item-1").name).to eq("First")
+    end
+  end
+
+  describe "corrupt file handling" do
+    it "warns and continues when a model file is corrupt" do
+      dir = File.join(tmpdir, "corrupt")
+      FileUtils.mkdir_p(File.join(dir, "items"))
+      File.write(File.join(dir, "items", "good.yaml"), "---\nid: good\nname: OK\n")
+      File.write(File.join(dir, "items", "bad.yaml"), "{{{{not yaml")
+
+      expect do
+        Lutaml::Store::PackageStore.load(definition, dir, transport: :directory)
+      end.to output(/failed to load/).to_stderr
+
+      loaded = Lutaml::Store::PackageStore.load(definition, dir,
+                                                transport: :directory)
+      expect(loaded.model_count(SimpleTestModel)).to eq(1)
+    end
+  end
+
+  describe "dir: nil (root-level models)" do
+    let(:root_definition) do
+      Lutaml::Store::PackageDefinition.new(name: :root_test) do |pkg|
+        pkg.model(model: SimpleTestModel, dir: nil,
+                  layout: :separate, key: :id, default_format: :yaml)
+      end
+    end
+
+    it "writes models to package root" do
+      store = Lutaml::Store::PackageStore.new(root_definition)
+      store.add_model(SimpleTestModel.new(id: "root-1", name: "Root"))
+
+      output_dir = File.join(tmpdir, "root")
+      store.save(output_dir, transport: :directory)
+
+      expect(File.exist?(File.join(output_dir, "root-1.yaml"))).to be true
+    end
+
+    it "reads models from package root" do
+      dir = File.join(tmpdir, "root_read")
+      FileUtils.mkdir_p(dir)
+      File.write(File.join(dir, "abc.yaml"), "---\nid: abc\nname: Found\n")
+
+      loaded = Lutaml::Store::PackageStore.load(root_definition, dir,
+                                                transport: :directory)
+      expect(loaded.model_count(SimpleTestModel)).to eq(1)
+      expect(loaded.fetch_model(SimpleTestModel, "abc").name).to eq("Found")
+    end
+  end
+end

data/spec/lutaml/store/package_transport/zip_transport_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/simple_test_model"
+require "zip"
+
+RSpec.describe Lutaml::Store::PackageTransport::ZipTransport do
+  let(:tmpdir) { Dir.mktmpdir }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  let(:definition) do
+    Lutaml::Store::PackageDefinition.new(
+      name: :test, metadata_model: SimpleTestModel, metadata_file: "meta.yaml",
+      metadata_key: :id
+    ) do |pkg|
+      pkg.model(model: SimpleTestModel, dir: "items",
+                layout: :separate, key: :id, default_format: :yaml)
+      pkg.asset("data.bin", type: :file)
+    end
+  end
+
+  describe "round-trip through ZIP" do
+    it "preserves models, metadata, and assets" do
+      store = Lutaml::Store::PackageStore.new(definition)
+      store.add_model(SimpleTestModel.new(id: "item-1", name: "First"))
+      store.metadata = SimpleTestModel.new(id: "meta", name: "Package")
+      store.add_asset("data.bin", "BINARY")
+
+      zip_path = File.join(tmpdir, "test.zip")
+      store.save(zip_path, transport: :zip)
+
+      expect(File.exist?(zip_path)).to be true
+
+      # Verify ZIP contents
+      Zip::File.open(zip_path) do |zf|
+        expect(zf.find_entry("meta.yaml")).not_to be_nil
+        expect(zf.find_entry("items/item-1.yaml")).not_to be_nil
+        expect(zf.find_entry("data.bin")).not_to be_nil
+      end
+
+      # Load from ZIP
+      loaded = Lutaml::Store::PackageStore.load(definition, zip_path,
+                                                transport: :zip)
+      expect(loaded.model_count(SimpleTestModel)).to eq(1)
+      expect(loaded.metadata.name).to eq("Package")
+      expect(loaded.asset("data.bin")).to eq("BINARY")
+    end
+  end
+
+  describe "directory → ZIP → directory round-trip" do
+    it "preserves data through format conversion" do
+      dir = File.join(tmpdir, "source")
+      dir_store = Lutaml::Store::PackageStore.new(definition)
+      dir_store.add_model(SimpleTestModel.new(id: "abc", name: "Test"))
+      dir_store.metadata = SimpleTestModel.new(id: "meta", name: "Dir Package")
+      dir_store.save(dir, transport: :directory)
+
+      loaded_from_dir = Lutaml::Store::PackageStore.load(definition, dir,
+                                                         transport: :directory)
+      zip_path = File.join(tmpdir, "converted.zip")
+      loaded_from_dir.save(zip_path, transport: :zip)
+
+      loaded_from_zip = Lutaml::Store::PackageStore.load(definition, zip_path,
+                                                         transport: :zip)
+      expect(loaded_from_zip.model_count(SimpleTestModel)).to eq(1)
+      expect(loaded_from_zip.fetch_model(SimpleTestModel, "abc").name).to eq("Test")
+      expect(loaded_from_zip.metadata.name).to eq("Dir Package")
+    end
+  end
+
+  describe "format override in ZIP" do
+    it "writes models in JSON format" do
+      store = Lutaml::Store::PackageStore.new(definition)
+      store.add_model(SimpleTestModel.new(id: "item-1", name: "First"))
+
+      zip_path = File.join(tmpdir, "json.zip")
+      store.save(zip_path, transport: :zip,
+                           formats: { SimpleTestModel => :json })
+
+      Zip::File.open(zip_path) do |zf|
+        expect(zf.find_entry("items/item-1.json")).not_to be_nil
+      end
+    end
+  end
+end

data/spec/support/simple_test_model.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Simple model with key_value DSL for testing package components
+# without depending on glossarist or lutaml-jsonschema.
+class SimpleTestModel < Lutaml::Model::Serializable
+  attribute :id, :string
+  attribute :name, :string
+  attribute :value, :string
+
+  key_value do
+    map "id", to: :id
+    map "name", to: :name
+    map "value", to: :value
+  end
+end

data/spec/support/yamls_test_model.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Minimal model with yamls DSL for testing Format::Yamls.
+# Structure mirrors ConceptDocument: header + collection of parts.
+class YamlsTestHeader < Lutaml::Model::Serializable
+  attribute :id, :string
+  attribute :name, :string
+
+  yaml do
+    map "id", to: :id
+    map "name", to: :name
+  end
+end
+
+class YamlsTestPart < Lutaml::Model::Serializable
+  attribute :label, :string
+  attribute :value, :string
+
+  yaml do
+    map "label", to: :label
+    map "value", to: :value
+  end
+end
+
+class YamlsTestModel < Lutaml::Model::Serializable
+  attribute :header, YamlsTestHeader
+  attribute :parts, YamlsTestPart, collection: true
+
+  yamls do
+    sequence do
+      map_document 0, to: :header, type: YamlsTestHeader
+      map_document 1.., to: :parts, type: YamlsTestPart, collection: true
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-store
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Ronald Tse
@@ -23,6 +23,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.15
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
 description: |
   Provides a unified store interface for Lutaml::Model objects with model registry,
   polymorphic support, composite relationships, and multiple storage backends
@@ -110,6 +124,9 @@ files:
 - lib/lutaml/store/model_registry.rb
 - lib/lutaml/store/model_serializer.rb
 - lib/lutaml/store/monitor.rb
+- lib/lutaml/store/package_definition.rb
+- lib/lutaml/store/package_store.rb
+- lib/lutaml/store/package_transport.rb
 - lib/lutaml/store/storage_key.rb
 - lib/lutaml/store/version.rb
 - lutaml-store.gemspec
@@ -126,6 +143,7 @@ files:
 - spec/lutaml/store/custom_serializer_spec.rb
 - spec/lutaml/store/database_store_spec.rb
 - spec/lutaml/store/file_io_spec.rb
+- spec/lutaml/store/format/yamls_spec.rb
 - spec/lutaml/store/format_round_trip_spec.rb
 - spec/lutaml/store/format_spec.rb
 - spec/lutaml/store/http_cache_entry_spec.rb
@@ -138,9 +156,15 @@ files:
 - spec/lutaml/store/load_save_spec.rb
 - spec/lutaml/store/lutaml_model_integration_spec.rb
 - spec/lutaml/store/model_serializer_spec.rb
+- spec/lutaml/store/package_definition_spec.rb
+- spec/lutaml/store/package_store_spec.rb
+- spec/lutaml/store/package_transport/directory_transport_spec.rb
+- spec/lutaml/store/package_transport/zip_transport_spec.rb
 - spec/lutaml/store/store_spec.rb
 - spec/lutaml/store_spec.rb
 - spec/spec_helper.rb
+- spec/support/simple_test_model.rb
+- spec/support/yamls_test_model.rb
 homepage: https://github.com/lutaml/lutaml-store
 licenses:
 - BSD-2-Clause