lutaml-store 0.1.1

data/spec/lutaml/store/anti_pattern_guard_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Enforces code quality rules from CLAUDE.md global instructions.
+# These specs MUST pass — any failure means an anti-pattern was introduced.
+RSpec.describe "Anti-pattern guard" do
+  lib_dir = File.expand_path("../../../lib", __dir__)
+  rb_files = Dir.glob(File.join(lib_dir, "**", "*.rb"))
+
+  rb_files.each do |path|
+    rel = path.sub("#{lib_dir}/", "")
+
+    it "#{rel} does not use .send() to call private methods" do
+      code = File.read(path).lines.reject { |l| l.strip.start_with?("#") }.join
+      code = code.gsub(/#.*$/, "")
+      uses = code.scan(/\.send\s*\(/)
+      expect(uses).to be_empty, "#{rel} uses .send() — refactor to use a public API"
+    end
+
+    it "#{rel} does not use instance_variable_get or instance_variable_set" do
+      code = File.read(path).lines.reject { |l| l.strip.start_with?("#") }.join
+      code = code.gsub(/#.*$/, "")
+      uses = code.scan(/instance_variable_(get|set)/)
+      expect(uses).to be_empty, "#{rel} uses instance_variable_get/set — add a public accessor"
+    end
+
+    it "#{rel} does not use respond_to? for type checking" do
+      code = File.read(path).lines.reject { |l| l.strip.start_with?("#") }.join
+      code = code.gsub(/#.*$/, "")
+      uses = code.scan(/respond_to\?\s*/)
+      expect(uses).to be_empty, "#{rel} uses respond_to? — use is_a? or redesign the type hierarchy"
+    end
+  end
+end

data/spec/lutaml/store/anti_pattern_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Anti-pattern regression prevention" do
+  let(:lib_dir) { File.expand_path("../../lib/lutaml/store", __dir__) }
+
+  def ruby_files
+    Dir.glob(File.join(lib_dir, "**", "*.rb"))
+  end
+
+  def file_contents
+    ruby_files.to_h { |f| [f, File.read(f)] }
+  end
+
+  describe "no respond_to? in lib code" do
+    it "contains zero respond_to? calls" do
+      offenders = file_contents.filter_map do |path, content|
+        matches = content.scan(/^.*respond_to\?.*$/)
+        next if matches.empty?
+        next if matches.all? { |line| line.strip.start_with?("#") }
+
+        rel = path.sub(%r{.*lib/}, "")
+        count = matches.count { |line| !line.strip.start_with?("#") }
+        "#{rel}: #{count} occurrence(s)"
+      end
+
+      expect(offenders).to be_empty,
+                           "Found respond_to? in lib code:\n#{offenders.join("\n")}"
+    end
+  end
+
+  describe "no instance_variable_get/set in lib code" do
+    it "contains zero instance_variable_get calls" do
+      offenders = file_contents.filter_map do |path, content|
+        matches = content.scan(/^.*instance_variable_get.*$/)
+        next if matches.empty?
+        next if matches.all? { |line| line.strip.start_with?("#") }
+
+        rel = path.sub(%r{.*lib/}, "")
+        "#{rel}: #{matches.size} occurrence(s)"
+      end
+
+      expect(offenders).to be_empty,
+                           "Found instance_variable_get in lib code:\n#{offenders.join("\n")}"
+    end
+
+    it "contains zero instance_variable_set calls" do
+      offenders = file_contents.filter_map do |path, content|
+        matches = content.scan(/^.*instance_variable_set.*$/)
+        next if matches.empty?
+        next if matches.all? { |line| line.strip.start_with?("#") }
+
+        rel = path.sub(%r{.*lib/}, "")
+        "#{rel}: #{matches.size} occurrence(s)"
+      end
+
+      expect(offenders).to be_empty,
+                           "Found instance_variable_set in lib code:\n#{offenders.join("\n")}"
+    end
+  end
+
+  describe "no send on private methods in lib code" do
+    it "contains zero .send( calls" do
+      offenders = file_contents.filter_map do |path, content|
+        matches = content.scan(/^.*\.send\(.*$/)
+        next if matches.empty?
+        next if matches.all? { |line| line.strip.start_with?("#") }
+
+        rel = path.sub(%r{.*lib/}, "")
+        "#{rel}: #{matches.size} occurrence(s)"
+      end
+
+      expect(offenders).to be_empty,
+                           "Found .send( in lib code:\n#{offenders.join("\n")}"
+    end
+  end
+end

data/spec/lutaml/store/autoload_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Autoload" do
+  it "loads BasicStore without sqlite3" do
+    store = Lutaml::Store::BasicStore.new(adapter_type: :memory)
+    store.set("key", "value")
+    expect(store.get("key")).to eq("value")
+
+    sqlite_loaded = $LOADED_FEATURES.any? { |path| path.include?("sqlite3") }
+    expect(sqlite_loaded).to be false
+  end
+
+  it "loads all constants lazily" do
+    # After requiring lutaml/store, only error classes and autoload entries exist
+    expect(Lutaml::Store::Error).to be_a(Class)
+    expect(Lutaml::Store::ConfigurationError).to be_a(Class)
+    expect(Lutaml::Store::BackendError).to be_a(Class)
+  end
+
+  it "loads DatabaseStore on first use" do
+    expect(defined?(Lutaml::Store::DatabaseStore)).to eq("constant")
+  end
+
+  it "loads Adapter::Base and subclasses on first reference" do
+    expect(defined?(Lutaml::Store::Adapter::Base)).to eq("constant")
+    expect(defined?(Lutaml::Store::Adapter::Memory)).to eq("constant")
+  end
+
+  it "loads BasicStore lazily" do
+    expect(defined?(Lutaml::Store::BasicStore)).to eq("constant")
+  end
+end

data/spec/lutaml/store/cache_store_spec.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store::CacheStore do
+  let(:config) do
+    {
+      adapter: {
+        type: :memory
+      },
+      default_ttl: 60,
+      max_size: 100,
+      cleanup_interval: 10
+    }
+  end
+  let(:cache) { described_class.new(config) }
+
+  describe "CacheEntry" do
+    let(:entry) { described_class::CacheEntry.new("value", ttl: 60, metadata: { source: "test" }) }
+
+    it "tracks creation time" do
+      expect(entry.created_at).to be_within(1).of(Time.now)
+    end
+
+    it "calculates expiration" do
+      expect(entry.expired?).to be false
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(entry.created_at + 61)
+      expect(entry.expired?).to be true
+    end
+
+    it "calculates expires_at" do
+      expect(entry.expires_at).to be_within(1).of(entry.created_at + 60)
+    end
+
+    it "serializes to hash" do
+      hash = entry.to_h
+      expect(hash).to include(:value, :created_at, :ttl, :expires_at, :metadata)
+      expect(hash[:value]).to eq("value")
+      expect(hash[:ttl]).to eq(60)
+      expect(hash[:metadata]).to eq({ source: "test" })
+    end
+
+    it "deserializes from hash" do
+      hash = entry.to_h
+      restored = described_class::CacheEntry.from_h(hash)
+
+      expect(restored.value).to eq(entry.value)
+      expect(restored.ttl).to eq(entry.ttl)
+      expect(restored.metadata).to eq(entry.metadata)
+      expect(restored.created_at).to be_within(1).of(entry.created_at)
+    end
+  end
+
+  describe "#set and #get" do
+    it "stores and retrieves values" do
+      cache.set("key1", "value1")
+      expect(cache.get("key1")).to eq("value1")
+    end
+
+    it "returns nil for non-existent keys" do
+      expect(cache.get("nonexistent")).to be_nil
+    end
+
+    it "respects TTL" do
+      cache.set("key1", "value1", ttl: 1)
+      expect(cache.get("key1")).to eq("value1")
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+      expect(cache.get("key1")).to be_nil
+    end
+
+    it "uses default TTL when not specified" do
+      cache.set("key1", "value1")
+      expect(cache.ttl("key1")).to be_within(5).of(60)
+    end
+
+    it "stores metadata" do
+      cache.set("key1", "value1", metadata: { source: "api" })
+
+      entry_data = cache.adapter.get("key1")
+      parsed = JSON.parse(entry_data, symbolize_names: true)
+      expect(parsed[:metadata]).to eq({ source: "api" })
+    end
+  end
+
+  describe "#exists?" do
+    it "returns true for existing non-expired keys" do
+      cache.set("key1", "value1")
+      expect(cache.exists?("key1")).to be true
+    end
+
+    it "returns false for non-existent keys" do
+      expect(cache.exists?("nonexistent")).to be false
+    end
+
+    it "returns false for expired keys" do
+      cache.set("key1", "value1", ttl: 1)
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+      expect(cache.exists?("key1")).to be false
+    end
+  end
+
+  describe "#ttl" do
+    it "returns remaining TTL" do
+      cache.set("key1", "value1", ttl: 60)
+      expect(cache.ttl("key1")).to be_within(5).of(60)
+    end
+
+    it "returns nil for keys without TTL" do
+      cache.set("key1", "value1", ttl: nil)
+      expect(cache.ttl("key1")).to be_nil
+    end
+
+    it "returns nil for expired keys" do
+      cache.set("key1", "value1", ttl: 1)
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+      expect(cache.ttl("key1")).to be_nil
+    end
+  end
+
+  describe "#touch" do
+    it "updates TTL for existing key" do
+      cache.set("key1", "value1", ttl: 60)
+      cache.ttl("key1")
+
+      # Simulate some time passing
+      allow(Time).to receive(:now).and_return(Time.now + 30)
+
+      expect(cache.touch("key1", ttl: 120)).to be true
+      expect(cache.ttl("key1")).to be_within(5).of(120)
+    end
+
+    it "returns false for non-existent keys" do
+      expect(cache.touch("nonexistent")).to be false
+    end
+
+    it "returns false for expired keys" do
+      cache.set("key1", "value1", ttl: 1)
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+      expect(cache.touch("key1")).to be false
+    end
+  end
+
+  describe "#fetch" do
+    it "returns existing value" do
+      cache.set("key1", "value1")
+
+      result = cache.fetch("key1") { "new_value" }
+      expect(result).to eq("value1")
+    end
+
+    it "executes block for missing key" do
+      result = cache.fetch("key1") { "new_value" }
+      expect(result).to eq("new_value")
+      expect(cache.get("key1")).to eq("new_value")
+    end
+
+    it "returns nil for missing key without block" do
+      result = cache.fetch("key1")
+      expect(result).to be_nil
+    end
+
+    it "respects TTL in fetch" do
+      result = cache.fetch("key1", ttl: 30) { "new_value" }
+      expect(result).to eq("new_value")
+      expect(cache.ttl("key1")).to be_within(5).of(30)
+    end
+  end
+
+  describe "#cleanup_expired" do
+    it "removes expired entries" do
+      cache.set("key1", "value1", ttl: 1)
+      cache.set("key2", "value2", ttl: 60)
+
+      # Simulate time passing
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+
+      expired_count = cache.cleanup_expired
+      expect(expired_count).to eq(1)
+      expect(cache.exists?("key1")).to be false
+      expect(cache.exists?("key2")).to be true
+    end
+  end
+
+  describe "#cache_info" do
+    it "provides cache statistics" do
+      cache.set("key1", "value1", ttl: 1)
+      cache.set("key2", "value2", ttl: 60)
+
+      # Simulate time passing to expire one entry
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+
+      info = cache.cache_info
+      expect(info).to include(:total_entries, :valid_entries, :expired_entries, :max_size, :default_ttl)
+      expect(info[:total_entries]).to eq(2)
+      expect(info[:valid_entries]).to eq(1)
+      expect(info[:expired_entries]).to eq(1)
+    end
+  end
+
+  describe "LRU eviction" do
+    let(:small_cache) { described_class.new(config.merge(max_size: 2)) }
+
+    it "evicts least recently used entries when max size is reached" do
+      small_cache.set("key1", "value1")
+      small_cache.set("key2", "value2")
+
+      # Access key1 to make it more recently used
+      small_cache.get("key1")
+
+      # Adding key3 should evict key2 (least recently used)
+      small_cache.set("key3", "value3")
+
+      expect(small_cache.exists?("key1")).to be true
+      expect(small_cache.exists?("key2")).to be false
+      expect(small_cache.exists?("key3")).to be true
+    end
+  end
+
+  describe "#clear" do
+    it "removes all entries" do
+      cache.set("key1", "value1")
+      cache.set("key2", "value2")
+
+      cache.clear
+
+      expect(cache.size).to eq(0)
+      expect(cache.exists?("key1")).to be false
+      expect(cache.exists?("key2")).to be false
+    end
+  end
+
+  describe "#delete" do
+    it "removes specific entry" do
+      cache.set("key1", "value1")
+      cache.set("key2", "value2")
+
+      deleted_value = cache.delete("key1")
+
+      expect(deleted_value).to eq("value1")
+      expect(cache.exists?("key1")).to be false
+      expect(cache.exists?("key2")).to be true
+    end
+  end
+
+  describe "automatic cleanup" do
+    let(:auto_cache) { described_class.new(config.merge(cleanup_interval: 1)) }
+
+    it "automatically cleans up expired entries" do
+      auto_cache.set("key1", "value1", ttl: 1)
+
+      # Simulate time passing beyond cleanup interval and TTL
+      allow(Time).to receive(:now).and_return(Time.now + 2)
+
+      # Next operation should trigger cleanup
+      auto_cache.set("key2", "value2")
+
+      expect(auto_cache.exists?("key1")).to be false
+      expect(auto_cache.exists?("key2")).to be true
+    end
+  end
+end

data/spec/lutaml/store/compression_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store::Compression do
+  describe ".compress and .decompress" do
+    let(:test_data) { "Hello, World! This is a test string for compression." }
+
+    context "with gzip compression" do
+      it "compresses and decompresses data correctly" do
+        compressed = described_class.compress(test_data, "gzip")
+        expect(compressed).not_to eq(test_data)
+        # NOTE: For small strings, compression might actually increase size due to headers
+        # The important thing is that decompression works correctly
+
+        decompressed = described_class.decompress(compressed, "gzip")
+        expect(decompressed).to eq(test_data)
+      end
+
+      it "supports different compression levels" do
+        compressed_1 = described_class.compress(test_data, "gzip", 1)
+        compressed_9 = described_class.compress(test_data, "gzip", 9)
+
+        expect(compressed_1.length).to be >= compressed_9.length
+        expect(described_class.decompress(compressed_1, "gzip")).to eq(test_data)
+        expect(described_class.decompress(compressed_9, "gzip")).to eq(test_data)
+      end
+    end
+
+    context "with deflate compression" do
+      it "compresses and decompresses data correctly" do
+        compressed = described_class.compress(test_data, "deflate")
+        expect(compressed).not_to eq(test_data)
+
+        decompressed = described_class.decompress(compressed, "deflate")
+        expect(decompressed).to eq(test_data)
+      end
+    end
+
+    context "with unsupported algorithm" do
+      it "raises an error for unsupported compression algorithm" do
+        expect do
+          described_class.compress(test_data, "unsupported")
+        end.to raise_error(ArgumentError, /Unsupported compression algorithm/)
+      end
+
+      it "raises an error for unsupported decompression algorithm" do
+        expect do
+          described_class.decompress(test_data, "unsupported")
+        end.to raise_error(ArgumentError, /Unsupported compression algorithm/)
+      end
+    end
+  end
+
+  describe ".detect_algorithm" do
+    let(:test_data) { "Hello, World!" }
+
+    it "detects gzip compression" do
+      compressed = described_class.compress(test_data, "gzip")
+      expect(described_class.detect_algorithm(compressed)).to eq("gzip")
+    end
+
+    it "detects deflate compression" do
+      compressed = described_class.compress(test_data, "deflate")
+      expect(described_class.detect_algorithm(compressed)).to eq("deflate")
+    end
+
+    it "returns nil for uncompressed data" do
+      expect(described_class.detect_algorithm(test_data)).to be_nil
+    end
+  end
+
+  describe "SUPPORTED_ALGORITHMS" do
+    it "includes expected algorithms" do
+      expect(described_class::SUPPORTED_ALGORITHMS).to include("gzip", "deflate", "bzip2", "lz4", "zstd")
+    end
+  end
+end

data/spec/lutaml/store/config_enhanced_spec.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store::Config do
+  describe "enhanced configuration features" do
+    let(:enhanced_config) do
+      {
+        adapter_type: :memory,
+        adapter_options: {},
+        cache: {
+          enabled: true,
+          max_size: 500,
+          ttl: 3600
+        },
+        monitoring: {
+          enabled: true
+        },
+        events: {
+          async: true
+        },
+        serialization: {
+          formats: %w[marshal json yaml],
+          validate_on_write: true
+        },
+        compression: {
+          enabled: true,
+          algorithm: "gzip",
+          level: 9
+        }
+      }
+    end
+
+    subject { described_class.new(**enhanced_config) }
+
+    describe "serialization configuration" do
+      it "provides access to serialization formats" do
+        expect(subject.serialization_formats).to eq(%w[marshal json yaml])
+      end
+
+      it "provides access to validate_on_write setting" do
+        expect(subject.validate_on_write?).to be true
+      end
+
+      context "with default configuration" do
+        subject { described_class.new }
+
+        it "has default serialization formats" do
+          expect(subject.serialization_formats).to include("marshal", "hash", "json", "yaml", "xml", "toml")
+        end
+
+        it "has validate_on_write disabled by default" do
+          expect(subject.validate_on_write?).to be false
+        end
+      end
+    end
+
+    describe "compression configuration" do
+      it "provides access to compression enabled setting" do
+        expect(subject.compression_enabled?).to be true
+      end
+
+      it "provides access to compression algorithm" do
+        expect(subject.compression_algorithm).to eq("gzip")
+      end
+
+      it "provides access to compression level" do
+        expect(subject.compression_level).to eq(9)
+      end
+
+      context "with default configuration" do
+        subject { described_class.new }
+
+        it "has compression disabled by default" do
+          expect(subject.compression_enabled?).to be false
+        end
+
+        it "has default compression algorithm" do
+          expect(subject.compression_algorithm).to eq("gzip")
+        end
+
+        it "has default compression level" do
+          expect(subject.compression_level).to eq(6)
+        end
+      end
+    end
+
+    describe "configuration merging" do
+      it "merges partial configuration with defaults" do
+        config = described_class.new(compression: { enabled: true })
+        expect(config.compression_enabled?).to be true
+        expect(config.compression_algorithm).to eq("gzip") # default
+        expect(config.compression_level).to eq(6) # default
+      end
+    end
+
+    describe "YAML configuration loading" do
+      let(:yaml_config) do
+        <<~YAML
+          lutaml_store:
+            adapter:
+              type: filesystem
+              options:
+                path: /tmp/test_store
+            compression:
+              enabled: true
+              algorithm: deflate
+              level: 3
+            serialization:
+              validate_on_write: true
+              formats:
+                - json
+                - yaml
+        YAML
+      end
+
+      it "loads enhanced configuration from YAML" do
+        config = described_class.from_yaml(yaml_config)
+
+        expect(config.adapter_type).to eq(:filesystem)
+        expect(config.adapter_options[:path]).to eq("/tmp/test_store")
+        expect(config.compression_enabled?).to be true
+        expect(config.compression_algorithm).to eq("deflate")
+        expect(config.compression_level).to eq(3)
+        expect(config.validate_on_write?).to be true
+        expect(config.serialization_formats).to eq(%w[json yaml])
+      end
+    end
+
+    describe "#to_h" do
+      it "includes all configuration sections" do
+        hash = subject.to_h
+
+        expect(hash).to have_key(:adapter)
+        expect(hash).to have_key(:cache)
+        expect(hash).to have_key(:monitoring)
+        expect(hash).to have_key(:events)
+        # NOTE: to_h method needs to be updated to include new sections
+      end
+    end
+  end
+
+  describe "configuration validation" do
+    context "with invalid compression settings" do
+      it "validates compression algorithm" do
+        # This would require adding validation for compression settings
+        # in the Config class validate! method
+      end
+    end
+
+    context "with invalid serialization settings" do
+      it "validates serialization formats" do
+        # This would require adding validation for serialization settings
+        # in the Config class validate! method
+      end
+    end
+  end
+end