lutaml-store 0.2.0 → 0.2.2

data/lib/lutaml/store/adapter/base.rb

@@ -28,6 +28,10 @@ module Lutaml
           raise NotImplementedError
         end
 
+        def each_key(&block)
+          raise NotImplementedError
+        end
+
         def all
           raise NotImplementedError
         end

data/lib/lutaml/store/adapter/memory.rb

@@ -93,6 +93,14 @@ module Lutaml
           end
         end
 
+        def each_key(&block)
+          current_keys = @mutex.synchronize do
+            cleanup_expired if @ttl_enabled
+            @data.keys
+          end
+          current_keys.each(&block)
+        end
+
         def close
           @mutex.synchronize do
             @data.clear

data/lib/lutaml/store/adapter.rb

@@ -7,6 +7,23 @@ module Lutaml
       autoload :Memory, "lutaml/store/adapter/memory"
       autoload :FileSystem, "lutaml/store/adapter/filesystem"
       autoload :Sqlite, "lutaml/store/adapter/sqlite"
+
+      @registry = {
+        memory: "Memory",
+        filesystem: "FileSystem",
+        sqlite: "Sqlite"
+      }
+
+      def self.resolve(type, options = {})
+        entry = @registry[type.to_sym]
+        raise ConfigurationError, "Unknown adapter type: #{type}" unless entry
+
+        const_get(entry).new(options)
+      end
+
+      def self.register(type, adapter_class)
+        @registry[type.to_sym] = adapter_class.name
+      end
     end
   end
 end

data/lib/lutaml/store/basic_store.rb

@@ -167,16 +167,7 @@ module Lutaml
       end
 
       def create_adapter
-        case @config.adapter_type
-        when :memory
-          Adapter::Memory.new(@config.adapter_options)
-        when :filesystem
-          Adapter::FileSystem.new(@config.adapter_options)
-        when :sqlite
-          Adapter::Sqlite.new(@config.adapter_options)
-        else
-          raise ConfigurationError, "Unknown adapter type: #{@config.adapter_type}"
-        end
+        Adapter.resolve(@config.adapter_type, @config.adapter_options)
       end
 
       def create_cache

data/lib/lutaml/store/cache_store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "time"
 
 module Lutaml
   module Store
@@ -222,15 +223,18 @@ module Lutaml
         end
       end
 
-      def fetch(key, ttl: :default, metadata: {}, &block)
+      def fetch(key, default = nil, ttl: :default, metadata: {})
         value = get(key)
         return value unless value.nil?
 
-        return nil unless block_given?
-
-        value = block.call
-        set(key, value, ttl: ttl, metadata: metadata)
-        value
+        if block_given?
+          value = yield
+          set(key, value, ttl: ttl, metadata: metadata)
+          value
+        elsif !default.nil?
+          set(key, default, ttl: ttl, metadata: metadata)
+          default
+        end
       end
 
       def close
@@ -243,16 +247,7 @@ module Lutaml
         adapter_type = config[:adapter]&.dig(:type) || config[:adapter_type] || :memory
         adapter_options = config[:adapter]&.dig(:options) || config[:adapter_options] || {}
 
-        case adapter_type.to_sym
-        when :memory
-          Adapter::Memory.new(adapter_options)
-        when :filesystem
-          Adapter::FileSystem.new(adapter_options)
-        when :sqlite
-          Adapter::Sqlite.new(adapter_options)
-        else
-          raise ConfigurationError, "Unknown adapter type: #{adapter_type}"
-        end
+        Adapter.resolve(adapter_type, adapter_options)
       end
 
       def serialize_entry(entry)

data/lib/lutaml/store/database_store.rb

@@ -207,7 +207,7 @@ module Lutaml
 
         content = fmt.serialize_many(models_array)
 
-        File.write(path, content, encoding: "utf-8")
+        write_file(path, content, fmt)
         @store.emit_event(:model_export, count: models_array.size, path: path)
         path
       end
@@ -331,8 +331,8 @@ module Lutaml
         Dir.glob(glob).sort.each do |file_path|
           next unless File.file?(file_path)
 
-          raw = File.read(file_path, encoding: "utf-8")
-          next if raw.strip.empty?
+          raw = read_file(file_path, fmt)
+          next if !fmt.binary? && raw.strip.empty?
 
           begin
             model = fmt.deserialize(raw, model_class)
@@ -351,8 +351,8 @@ module Lutaml
         Dir.glob(glob).sort.each do |file_path|
           next unless File.file?(file_path)
 
-          raw = File.read(file_path, encoding: "utf-8")
-          next if raw.strip.empty?
+          raw = read_file(file_path, fmt)
+          next if !fmt.binary? && raw.strip.empty?
 
           begin
             loaded = fmt.deserialize_many(raw, model_class)
@@ -375,8 +375,7 @@ module Lutaml
           key = extract_model_key(model)
           filename = key || model.class.name.to_s.gsub("::", "_")
           file_path = File.join(dir, "#{filename}#{fmt.extension}")
-          content = fmt.serialize(model)
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, fmt.serialize(model), fmt)
           model
         end
       end
@@ -391,8 +390,7 @@ module Lutaml
 
         grouped.map do |key, group|
           file_path = File.join(dir, "#{key}#{fmt.extension}")
-          content = fmt.serialize_many(group)
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, fmt.serialize_many(group), fmt)
           group
         end.flatten
       end
@@ -420,6 +418,18 @@ module Lutaml
         basename = File.basename(file_path, ".*")
         model.public_send(:"#{registration.key_field}=", basename)
       end
+
+      def read_file(file_path, fmt)
+        fmt.binary? ? File.binread(file_path) : File.read(file_path, encoding: "utf-8")
+      end
+
+      def write_file(file_path, content, fmt)
+        if fmt.binary?
+          File.binwrite(file_path, content)
+        else
+          File.write(file_path, content, encoding: "utf-8")
+        end
+      end
     end
   end
 end

data/lib/lutaml/store/format/base.rb

@@ -27,6 +27,10 @@ module Lutaml
         def deserialize_many(_data, _model_class)
           raise NotImplementedError, "#{self.class} does not support multi-document deserialization"
         end
+
+        def binary?
+          false
+        end
       end
     end
   end

data/lib/lutaml/store/format/marshal_format.rb

@@ -31,6 +31,10 @@ module Lutaml
           hash_array = ::Marshal.load(data)
           hash_array.map { |h| model_class.from_hash(h) }
         end
+
+        def binary?
+          true
+        end
       end
     end
   end

data/lib/lutaml/store/format/xml.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    module Format
+      class Xml < Base
+        def extension
+          ".xml"
+        end
+
+        def glob_pattern
+          "*.xml"
+        end
+
+        def serialize(model)
+          model.to_xml
+        end
+
+        def deserialize(data, model_class)
+          model_class.from_xml(data)
+        end
+
+        def serialize_many(models)
+          inner = models.map(&:to_xml).join("\n")
+          "<items>\n#{inner}\n</items>"
+        end
+
+        def deserialize_many(data, model_class)
+          doc = Moxml.parse(data)
+          doc.root.children.select(&:element?).map do |child|
+            model_class.from_xml(child.to_xml)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/format/yamls.rb

@@ -17,7 +17,7 @@ module Lutaml
         end
 
         def serialize_many(models)
-          models.map(&:to_yamls).join
+          models.map(&:to_yamls).join("\n")
         end
 
         def deserialize(data, model_class)

data/lib/lutaml/store/format.rb

@@ -13,13 +13,15 @@ module Lutaml
       autoload :Json, "lutaml/store/format/json"
       autoload :Jsonl, "lutaml/store/format/jsonl"
       autoload :MarshalFormat, "lutaml/store/format/marshal_format"
+      autoload :Xml, "lutaml/store/format/xml"
 
       FORMATS = {
         yaml: "Yaml",
         yamls: "Yamls",
         json: "Json",
         jsonl: "Jsonl",
-        marshal: "MarshalFormat"
+        marshal: "MarshalFormat",
+        xml: "Xml"
       }.freeze
 
       def self.resolve(format)
@@ -28,6 +30,25 @@ module Lutaml
 
         const_get(entry).new
       end
+
+      def self.for_extension(ext)
+        extension_map[ext] || extension_map[".#{ext.to_s.sub(/\A\./, "")}"]
+      end
+
+      private_class_method def self.extension_map
+        @extension_map ||= begin
+          map = {}
+          FORMATS.each_value do |class_name|
+            fmt = const_get(class_name).new
+            ext = fmt.extension
+            next if map.key?(ext)
+
+            map[ext] = fmt
+            map[".yml"] = fmt if ext == ".yaml"
+          end
+          map.freeze
+        end
+      end
     end
   end
 end

data/lib/lutaml/store/format_serializer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Bridges a Format handler to the ModelSerializer interface.
+    # Enables DatabaseStore to use any format (yaml, json, xml, yamls, marshal)
+    # for key-value storage instead of the default hash serialization.
+    #
+    # Usage:
+    #   serializer = FormatSerializer.new(:yamls)
+    #   store = DatabaseStore.new(
+    #     adapter: :sqlite,
+    #     models: [{ model: ConceptDocument, key: :id, serializer: serializer }]
+    #   )
+    class FormatSerializer
+      DATA_KEY = "_data"
+      CLASS_KEY = "_class"
+
+      def initialize(format)
+        @format = Format.resolve(format)
+      end
+
+      def serialize(model)
+        {
+          DATA_KEY => @format.serialize(model),
+          CLASS_KEY => model.class.name
+        }
+      end
+
+      def deserialize(data, model_class)
+        model_class = resolve_class(data[CLASS_KEY]) if data[CLASS_KEY]
+        @format.deserialize(data[DATA_KEY], model_class)
+      end
+
+      private
+
+      def resolve_class(class_name)
+        Object.const_get(class_name)
+      rescue NameError
+        nil
+      end
+    end
+  end
+end

data/lib/lutaml/store/http_cache.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "json"
-
 module Lutaml
   module Store
     class HttpCache
@@ -145,9 +143,7 @@ module Lutaml
           data = @adapter.get(key)
           next unless data
 
-          entry_data = data.is_a?(String) ? JSON.parse(data) : data
-          entry = HttpCacheEntry.from_hash(entry_data)
-          entries << entry
+          entries << HttpCacheEntry.from_json(data)
         rescue StandardError
           # Skip invalid entries
         end
@@ -174,20 +170,14 @@ module Lutaml
         data = @adapter.get(cache_key)
         return nil unless data
 
-        # Handle both serialized and hash data
-        entry_data = data.is_a?(String) ? JSON.parse(data) : data
-        HttpCacheEntry.from_hash(entry_data)
+        HttpCacheEntry.from_json(data)
       rescue StandardError
-        # Log error and continue without cache
         nil
       end
 
       def store_entry(cache_key, entry)
-        # Serialize entry for storage
-        data = entry.to_hash
-        @adapter.set(cache_key, data)
+        @adapter.set(cache_key, entry.to_json)
       rescue StandardError
-        # Log error but don't fail the request
         false
       end
 

data/lib/lutaml/store/model_registration.rb

@@ -4,14 +4,17 @@ module Lutaml
   module Store
     # Represents a single model registration with its metadata
     class ModelRegistration
-      attr_reader :model_class, :key_field, :polymorphic_class_key, :serializer, :dir
+      attr_reader :model_class, :key_field, :polymorphic_class_key, :serializer, :dir,
+                  :composites
 
-      def initialize(model_class, key_field, polymorphic_class_key: nil, serializer: nil, dir: nil)
+      def initialize(model_class, key_field, polymorphic_class_key: nil, serializer: nil,
+                     dir: nil, composites: [])
         @model_class = model_class
         @key_field = key_field.to_sym
         @polymorphic_class_key = polymorphic_class_key&.to_sym
         @serializer = serializer
         @dir = dir
+        @composites = composites.map(&:to_sym)
         validate!
       end
 

data/lib/lutaml/store/model_registry.rb

@@ -81,34 +81,36 @@ module Lutaml
         @registrations.clear
       end
 
-      # Find models that are registered and nested within other models
+      # Find declared composite models nested within the given model
       def find_composite_models(model)
-        composite_models = {}
+        registration = find_registration(model.class)
+        return {} unless registration&.composites&.any?
 
-        model.class.attributes.each_key do |attr_name|
-          attr_value = model.public_send(attr_name)
-          next if attr_value.nil?
-
-          if attr_value.is_a?(Object) && registered?(attr_value.class)
-            add_composite_entry(composite_models, attr_name,
-                                attr_value)
-          end
+        registration.composites.each_with_object({}) do |attr_name, result|
+          collect_composite(model, attr_name, result)
+        end
+      end
 
-          next unless attr_value.is_a?(Array)
+      private
 
-          attr_value.each_with_index do |item, index|
-            next unless item.is_a?(Object) && registered?(item.class)
+      def collect_composite(model, attr_name, result)
+        attr_value = model.public_send(attr_name)
+        return if attr_value.nil?
 
-            add_composite_entry(composite_models, "#{attr_name}.#{index}", item)
-          end
+        if attr_value.is_a?(Array)
+          collect_array_composites(attr_value, attr_name, result)
+        elsif registered?(attr_value.class)
+          add_composite_entry(result, attr_name, attr_value)
         end
-
-        composite_models
-      rescue NoMethodError
-        {}
       end
 
-      private
+      def collect_array_composites(values, attr_name, result)
+        values.each_with_index do |item, index|
+          next unless registered?(item.class)
+
+          add_composite_entry(result, "#{attr_name}.#{index}", item)
+        end
+      end
 
       def add_composite_entry(composite_models, attr_path, model_instance)
         registration = find_registration(model_instance.class)

data/lib/lutaml/store/package_store.rb

@@ -20,15 +20,13 @@ module Lutaml
 
       def self.load(definition, path, transport: :directory, format: nil)
         store = new(definition)
-        transporter = resolve_transport(transport)
-        transporter.read(path, store, format: format)
+        PackageTransport.resolve(transport).read(path, store, format: format)
         store
       end
 
       def save(path, transport: :directory, format: nil, formats: {})
         resolved_formats = resolve_formats(format, formats)
-        transporter = self.class.resolve_transport(transport)
-        transporter.write(path, self, formats: resolved_formats)
+        PackageTransport.resolve(transport).write(path, self, formats: resolved_formats)
       end
 
       # ── Model CRUD ──
@@ -118,22 +116,8 @@ module Lutaml
         }
       end
 
-      # Public access for PackageTransport (avoids instance_variable_get).
-      attr_reader :db
-
       private
 
-      def self.resolve_transport(transport)
-        case transport
-        when :directory, "directory"
-          PackageTransport::DirectoryTransport.new
-        when :zip, "zip"
-          PackageTransport::ZipTransport.new
-        else
-          raise ConfigurationError, "Unknown transport: #{transport}"
-        end
-      end
-
       def resolve_formats(global_format, per_model_formats)
         if global_format
           definition.model_entries

data/lib/lutaml/store/package_transport/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Lutaml
+  module Store
+    module PackageTransport
+      class Base
+        def read(path, package_store, format: nil)
+          raise NotImplementedError
+        end
+
+        def write(path, package_store, formats: {})
+          raise NotImplementedError
+        end
+
+        private
+
+        def resolve_format(format_name)
+          Format.resolve(format_name)
+        end
+
+        def effective_format(entry, formats)
+          formats[entry.model] || entry.default_format
+        end
+
+        def format_for_file(filename)
+          Format.for_extension(File.extname(filename)) || Format.resolve(:yaml)
+        end
+
+        def extract_key(model, entry)
+          model.public_send(entry.key).to_s
+        end
+
+        def set_key_from_filename(model, filename, entry)
+          return if model.public_send(entry.key)
+
+          basename = File.basename(filename, ".*")
+          model.public_send(:"#{entry.key}=", basename)
+        end
+
+        def sanitize_filename(key)
+          key.gsub(%r{[/:#?]}, "_")
+        end
+
+        def read_file(file_path, fmt)
+          fmt.binary? ? File.binread(file_path) : File.read(file_path, encoding: "utf-8")
+        end
+
+        def write_file(file_path, content, fmt)
+          if fmt.binary?
+            File.binwrite(file_path, content)
+          else
+            File.write(file_path, content, encoding: "utf-8")
+          end
+        end
+      end
+    end
+  end
+end