lutaml-store 0.1.1 → 0.2.1

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/attribute_updater.rb

@@ -100,10 +100,16 @@ module Lutaml
 
         parts.each_with_index do |part, index|
           if part.match?(/\A\d+\z/)
-            raise InvalidKeyError, "Expected array at #{parts[0..index - 1].join(".")}, got #{current.class}" unless current.is_a?(Array)
+            unless current.is_a?(Array)
+              raise InvalidKeyError,
+                    "Expected array at #{parts[0..index - 1].join(".")}, got #{current.class}"
+            end
 
             index_val = part.to_i
-            raise InvalidKeyError, "Array index #{index_val} out of bounds for #{parts[0..index - 1].join(".")}" if index_val >= current.length
+            if index_val >= current.length
+              raise InvalidKeyError,
+                    "Array index #{index_val} out of bounds for #{parts[0..index - 1].join(".")}"
+            end
 
             current = current[index_val]
           else
@@ -130,7 +136,10 @@ module Lutaml
         end
 
         current_model = model.public_send(attr_name)
-        validate_polymorphic_key_compatibility!(current_model, new_polymorphic_model) if current_model && @registry.registered?(current_model.class)
+        if current_model && @registry.registered?(current_model.class)
+          validate_polymorphic_key_compatibility!(current_model,
+                                                  new_polymorphic_model)
+        end
 
         model.public_send("#{attr_name}=", new_polymorphic_model)
       end

data/lib/lutaml/store/basic_store.rb

@@ -98,6 +98,10 @@ module Lutaml
         @adapter.keys
       end
 
+      def each_key(&block)
+        @adapter.keys.each(&block)
+      end
+
       def bulk_get(keys)
         @adapter.bulk_get(keys)
       end

data/lib/lutaml/store/cache_store.rb

@@ -170,7 +170,7 @@ module Lutaml
       def cleanup_expired
         expired_keys = []
 
-        @adapter.keys.each do |key|
+        @adapter.each_key do |key|
           entry_data = @adapter.get(key)
           next unless entry_data
 
@@ -222,15 +222,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

data/lib/lutaml/store/database_store.rb

@@ -106,7 +106,7 @@ module Lutaml
         registration = @registry.registration_for(model)
 
         models = []
-        @store.keys.each do |storage_key|
+        @store.each_key do |storage_key|
           parsed = StorageKey.parse(storage_key.to_s)
           next unless parsed.class_name == model.name
 

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

@@ -13,11 +13,11 @@ module Lutaml
         end
 
         def serialize(model)
-          model.to_yaml
+          model.to_yamls
         end
 
         def serialize_many(models)
-          models.map(&:to_yaml).join
+          models.map(&:to_yamls).join
         end
 
         def deserialize(data, model_class)

data/lib/lutaml/store/format.rb

@@ -28,6 +28,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/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
 
@@ -236,7 +226,10 @@ module Lutaml
 
         # Extract vary header values from request
         request_vary_headers = {}
-        request_vary_headers = HttpHeaderProcessor.extract_vary_headers(request_headers, vary_headers) if vary_headers.any?
+        if vary_headers.any?
+          request_vary_headers = HttpHeaderProcessor.extract_vary_headers(request_headers,
+                                                                          vary_headers)
+        end
 
         HttpCacheEntry.new(
           cache_key: cache_key,

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,31 +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?
-
-          add_composite_entry(composite_models, attr_name, attr_value) if attr_value.is_a?(Object) && registered?(attr_value.class)
+        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_definition.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    class PackageDefinition
+      attr_reader :name, :model_entries, :asset_entries,
+                  :metadata_model, :metadata_file, :metadata_key
+
+      def initialize(name:, metadata_model: nil, metadata_file: nil,
+                     metadata_key: :shortname)
+        @name = name
+        @metadata_model = metadata_model
+        @metadata_file = metadata_file
+        @metadata_key = metadata_key
+        @model_entries = []
+        @asset_entries = []
+        yield self if block_given?
+      end
+
+      def model(model:, key:, dir: nil, file: nil, layout: :separate,
+                default_format: :yaml, serializer: nil)
+        raise ArgumentError, "Specify dir: or file:, not both" if dir && file
+
+        @model_entries << ModelEntry.new(
+          model: model, dir: dir, file: file, layout: layout,
+          key: key, default_format: default_format, serializer: serializer
+        )
+      end
+
+      def asset(path, type: :file)
+        @asset_entries << AssetEntry.new(path: path, type: type)
+      end
+
+      def entry_for(model_class)
+        @model_entries.find { |e| e.model == model_class }
+      end
+
+      def model_classes
+        @model_entries.map(&:model)
+      end
+
+      def database_store_models
+        @model_entries.map do |e|
+          config = { model: e.model, key: e.key }
+          config[:serializer] = e.serializer if e.serializer
+          config[:dir] = e.dir if e.dir
+          config
+        end
+      end
+
+      ModelEntry = Struct.new(
+        :model, :dir, :file, :layout, :key, :default_format, :serializer,
+        keyword_init: true
+      )
+
+      AssetEntry = Struct.new(
+        :path, :type,
+        keyword_init: true
+      )
+    end
+  end
+end

data/lib/lutaml/store/package_store.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    class PackageStore
+      attr_accessor :metadata
+      attr_reader :definition, :assets
+
+      def initialize(definition)
+        @definition = definition
+        @db = DatabaseStore.new(
+          adapter: :memory,
+          models: definition.database_store_models
+        )
+        @assets = {}
+        @metadata = nil
+      end
+
+      # ── Load / Save ──
+
+      def self.load(definition, path, transport: :directory, format: nil)
+        store = new(definition)
+        PackageTransport.resolve(transport).read(path, store, format: format)
+        store
+      end
+
+      def save(path, transport: :directory, format: nil, formats: {})
+        resolved_formats = resolve_formats(format, formats)
+        PackageTransport.resolve(transport).write(path, self, formats: resolved_formats)
+      end
+
+      # ── Model CRUD ──
+
+      def add_model(model_instance)
+        @db.save(model_instance)
+      end
+
+      def add_models(model_instances)
+        model_instances.each { |m| add_model(m) }
+      end
+
+      def fetch_model(model_class, key)
+        entry = definition.entry_for(model_class)
+        @db.fetch(model: model_class, **{ entry.key => key })
+      end
+
+      def models_for(model_class)
+        @db.all(model: model_class)
+      end
+
+      def model_count(model_class)
+        @db.count(model: model_class)
+      end
+
+      def model_exists?(model_class, key)
+        entry = definition.entry_for(model_class)
+        @db.exists?(model: model_class, **{ entry.key => key })
+      end
+
+      def remove_model(model_class, key)
+        entry = definition.entry_for(model_class)
+        @db.destroy(model: model_class, **{ entry.key => key })
+      end
+
+      # ── Metadata ──
+
+      # ── Assets ──
+
+      def asset(path)
+        @assets[path]
+      end
+
+      def add_asset(path, content)
+        @assets[path] = content
+      end
+
+      def asset_paths
+        @assets.keys
+      end
+
+      def remove_asset(path)
+        @assets.delete(path)
+      end
+
+      # ── Bulk ──
+
+      def clear_models(model_class)
+        @db.all(model: model_class).each do |m|
+          entry = definition.entry_for(model_class)
+          key = m.public_send(entry.key)
+          @db.destroy(model: model_class, **{ entry.key => key })
+        end
+      end
+
+      def clear_assets
+        @assets.clear
+      end
+
+      def clear_all
+        definition.model_classes.each { |mc| clear_models(mc) }
+        clear_assets
+        @metadata = nil
+      end
+
+      # ── Stats ──
+
+      def stats
+        model_stats = definition.model_classes
+                                .map { |mc| [mc.name, model_count(mc)] }
+                                .to_h
+        {
+          package: definition.name,
+          models: model_stats,
+          assets: @assets.size,
+          metadata: @metadata ? true : false
+        }
+      end
+
+      private
+
+      def resolve_formats(global_format, per_model_formats)
+        if global_format
+          definition.model_entries
+                    .map { |e| [e.model, global_format] }
+                    .to_h
+                    .merge(per_model_formats)
+        else
+          per_model_formats
+        end
+      end
+    end
+  end
+end

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

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