lutaml-store 0.2.0 → 0.2.1

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

@@ -1,139 +0,0 @@
-# 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

@@ -1,85 +0,0 @@
-# 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/lutaml/store/store_spec.rb

@@ -1,182 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe Lutaml::Store::BasicStore do
-  let(:store) { described_class.new }
-
-  describe "initialization" do
-    it "creates a store with default memory adapter" do
-      expect(store.adapter).to be_a(Lutaml::Store::Adapter::Memory)
-    end
-
-    it "creates a store with configuration hash" do
-      config = {
-        "adapter" => { "type" => "memory" },
-        "cache" => { "enabled" => false }
-      }
-      store = described_class.new(config)
-      expect(store.cache).to be_nil
-    end
-
-    it "creates a store with direct adapter instance" do
-      adapter = Lutaml::Store::Adapter::Memory.new
-      store = described_class.new(adapter)
-      expect(store.adapter).to eq(adapter)
-    end
-  end
-
-  describe "basic operations" do
-    it "stores and retrieves values" do
-      store.set("key1", "value1")
-      expect(store.get("key1")).to eq("value1")
-    end
-
-    it "returns nil for non-existent keys" do
-      expect(store.get("nonexistent")).to be_nil
-    end
-
-    it "deletes values" do
-      store.set("key1", "value1")
-      expect(store.delete("key1")).to be true
-      expect(store.get("key1")).to be_nil
-    end
-
-    it "checks key existence" do
-      store.set("key1", "value1")
-      expect(store.exists?("key1")).to be true
-      expect(store.exists?("nonexistent")).to be false
-    end
-
-    it "returns all data" do
-      store.set("key1", "value1")
-      store.set("key2", "value2")
-      expect(store.all).to eq("key1" => "value1", "key2" => "value2")
-    end
-
-    it "clears all data" do
-      store.set("key1", "value1")
-      store.clear
-      expect(store.size).to eq(0)
-    end
-
-    it "returns correct size" do
-      expect(store.size).to eq(0)
-      store.set("key1", "value1")
-      expect(store.size).to eq(1)
-    end
-  end
-
-  describe "caching" do
-    let(:config) do
-      {
-        "adapter" => { "type" => "memory" },
-        "cache" => { "enabled" => true, "max_size" => 10 }
-      }
-    end
-    let(:store) { described_class.new(config) }
-
-    it "caches retrieved values" do
-      store.set("key1", "value1")
-
-      # First get should hit backend
-      value1 = store.get("key1")
-      expect(value1).to eq("value1")
-
-      # Second get should hit cache
-      value2 = store.get("key1")
-      expect(value2).to eq("value1")
-
-      # Cache should contain the value
-      expect(store.cache_stats[:size]).to eq(1)
-    end
-
-    it "invalidates cache on delete" do
-      store.set("key1", "value1")
-      store.get("key1") # Cache the value
-
-      store.delete("key1")
-      expect(store.cache_stats[:size]).to eq(0)
-    end
-  end
-
-  describe "events" do
-    let(:events) { [] }
-
-    before do
-      store.on(:set) { |data| events << data }
-      store.on(:get) { |data| events << data }
-      store.on(:delete) { |data| events << data }
-    end
-
-    it "emits events for operations" do
-      store.set("key1", "value1")
-      store.get("key1")
-      store.delete("key1")
-
-      expect(events.size).to eq(3)
-      expect(events[0][:event]).to eq(:set)
-      expect(events[1][:event]).to eq(:get)
-      expect(events[2][:event]).to eq(:delete)
-    end
-  end
-
-  describe "monitoring" do
-    let(:config) do
-      {
-        "adapter" => { "type" => "memory" },
-        "monitoring" => { "enabled" => true }
-      }
-    end
-    let(:store) { described_class.new(config) }
-
-    it "tracks operation statistics" do
-      store.set("key1", "value1")
-      store.get("key1")
-
-      stats = store.stats
-      monitor_stats = stats[:monitor_stats]
-      expect(monitor_stats[:operations][:set]).to eq(1)
-      expect(monitor_stats[:operations][:get]).to eq(1)
-      # NOTE: total_operations includes the size call from stats method
-      expect(monitor_stats[:total_operations]).to be >= 2
-    end
-  end
-
-  describe "configuration from file" do
-    let(:config_file) { "test_config.yml" }
-    let(:config_content) do
-      <<~YAML
-        lutaml_store:
-          adapter:
-            type: memory
-          cache:
-            enabled: true
-            max_size: 500
-          monitoring:
-            enabled: true
-      YAML
-    end
-
-    before do
-      File.write(config_file, config_content)
-    end
-
-    after do
-      File.delete(config_file) if File.exist?(config_file)
-    end
-
-    it "loads configuration from YAML file" do
-      store = described_class.from_file(config_file)
-      expect(store.adapter).to be_a(Lutaml::Store::Adapter::Memory)
-      expect(store.cache).not_to be_nil
-      expect(store.monitor).not_to be_nil
-    end
-  end
-
-  describe "#close" do
-    it "closes resources properly" do
-      expect { store.close }.not_to raise_error
-    end
-  end
-end

data/spec/lutaml/store_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Lutaml::Store do
-  it "has a version number" do
-    expect(Lutaml::Store::VERSION).not_to be nil
-  end
-
-  it "provides access to Store and DatabaseStore classes" do
-    expect(Lutaml::Store::BasicStore).to be_a(Class)
-    expect(Lutaml::Store::DatabaseStore).to be_a(Class)
-  end
-
-  it "returns a DatabaseStore from .new" do
-    test_model = Struct.new(:id, :name)
-    store = Lutaml::Store.new(
-      adapter: :memory,
-      models: [{ model: test_model, key: :id }]
-    )
-    expect(store).to be_a(Lutaml::Store::DatabaseStore)
-  end
-end

data/spec/spec_helper.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-require "lutaml/store"
-
-RSpec.configure do |config|
-  # Enable flags like --only-failures and --next-failure
-  config.example_status_persistence_file_path = ".rspec_status"
-
-  # Disable RSpec exposing methods globally on `Module` and `main`
-  config.disable_monkey_patching!
-
-  config.expect_with :rspec do |c|
-    c.syntax = :expect
-  end
-end

data/spec/support/simple_test_model.rb

@@ -1,15 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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