lutaml-store 0.1.1

data/lib/lutaml/store/attribute_updater.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Processes model updates including dot notation for nested attributes
+    class AttributeUpdater
+      def initialize(registry, composite_handler)
+        @registry = registry
+        @composite_handler = composite_handler
+      end
+
+      # Update model with attribute array
+      def update_with_attributes(model, attributes)
+        return model if attributes.nil? || attributes.empty?
+
+        updated_model = model.dup
+
+        attributes.each do |attr_update|
+          key = attr_update[:key]
+          value = attr_update[:value]
+
+          if key.to_s.include?(".")
+            update_nested_attribute(updated_model, key.to_s, value)
+          else
+            update_direct_attribute(updated_model, key, value)
+          end
+        end
+
+        @composite_handler.update_composite_models(updated_model, attributes)
+
+        updated_model
+      end
+
+      # Update model with block
+      def update_with_block(model, &block)
+        return model unless block_given?
+
+        updated_model = model.dup
+        block.call(updated_model)
+
+        composite_models = @registry.find_composite_models(updated_model)
+        @composite_handler.process_composite_models(updated_model) unless composite_models.empty?
+
+        updated_model
+      end
+
+      # Update model with hash
+      def update_with_hash(model, updates_hash)
+        return model if updates_hash.nil? || updates_hash.empty?
+
+        attributes = updates_hash.map { |key, value| { key: key, value: value } }
+        update_with_attributes(model, attributes)
+      end
+
+      private
+
+      def update_nested_attribute(model, attr_path, value)
+        parts = attr_path.split(".")
+        current = model
+
+        parts[0..-2].each do |part|
+          current = if part.match?(/\A\d+\z/)
+                      current[part.to_i]
+                    else
+                      current.public_send(part)
+                    end
+
+          raise InvalidKeyError, "Cannot navigate to #{attr_path}: #{part} is nil" if current.nil?
+        end
+
+        final_attr = parts.last
+        if final_attr.match?(/\A\d+\z/)
+          current[final_attr.to_i] = value
+        else
+          setter_method = "#{final_attr}="
+          begin
+            current.public_send(setter_method, value)
+          rescue NoMethodError
+            raise InvalidKeyError, "No setter method #{setter_method} on #{current.class}"
+          end
+        end
+      end
+
+      def update_direct_attribute(model, attr_name, value)
+        setter_method = "#{attr_name}="
+
+        begin
+          model.public_send(setter_method, value)
+        rescue NoMethodError
+          return if try_polymorphic_upgrade(model, attr_name, value)
+
+          raise InvalidKeyError, "No setter method #{setter_method} on #{model.class}"
+        end
+      end
+
+      # Validate attribute path without respond_to? on leaf — use is_a? for type checking
+      def validate_attribute_path(model, attr_path)
+        parts = attr_path.split(".")
+        current = model
+
+        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)
+
+            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
+
+            current = current[index_val]
+          else
+            unless current.is_a?(Lutaml::Model::Serializable) || current.public_methods.include?(part.to_sym)
+              raise InvalidKeyError, "No method #{part} on #{current.class} at #{parts[0..index - 1].join(".")}"
+            end
+
+            current = current.public_send(part)
+          end
+        end
+      end
+
+      def extract_polymorphic_updates(attributes)
+        attributes.select do |attr_update|
+          value = attr_update[:value]
+          value.is_a?(Object) && @registry.registered?(value.class)
+        end
+      end
+
+      def handle_polymorphic_update(model, attr_name, new_polymorphic_model)
+        unless @registry.registered?(new_polymorphic_model.class)
+          raise PolymorphicUpdateError,
+                "Cannot update with unregistered model #{new_polymorphic_model.class}"
+        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)
+
+        model.public_send("#{attr_name}=", new_polymorphic_model)
+      end
+
+      # Try to upgrade a model to a polymorphic subclass that supports the attribute.
+      # Uses proper constructors instead of instance_variable_set/get.
+      def try_polymorphic_upgrade(model, attr_name, value)
+        return false unless @registry.registered?(model.class)
+
+        registration = @registry.registration_for(model.class)
+
+        @registry.registered_models.each do |registered_class|
+          next unless registered_class > model.class
+          next unless registered_class.instance_methods.include?("#{attr_name}=".to_sym)
+
+          subclass_registration = @registry.registration_for(registered_class)
+          next unless subclass_registration.key_field == registration.key_field
+
+          begin
+            current_data = model.to_hash
+            current_data[attr_name.to_s] = value
+
+            upgraded_model = registered_class.from_hash(current_data)
+            copy_model_attributes!(model, upgraded_model)
+            return true
+          rescue StandardError
+            next
+          end
+        end
+
+        false
+      end
+
+      # Copy all Lutaml::Model attributes from source to target using public setters
+      def copy_model_attributes!(target, source)
+        source.class.attributes.each_key do |attr_name|
+          setter = "#{attr_name}="
+          begin
+            target.public_send(setter, source.public_send(attr_name))
+          rescue NoMethodError
+            next
+          end
+        end
+      end
+
+      def validate_polymorphic_key_compatibility!(current_model, new_model)
+        current_registration = @registry.registration_for(current_model.class)
+        new_registration = @registry.registration_for(new_model.class)
+
+        if current_registration.key_field != new_registration.key_field
+          raise PolymorphicUpdateError,
+                "Key field mismatch: #{current_registration.key_field} vs #{new_registration.key_field}"
+        end
+
+        current_key = current_registration.extract_key(current_model)
+        new_key = new_registration.extract_key(new_model)
+
+        return unless current_key != new_key
+
+        raise PolymorphicUpdateError,
+              "Key value mismatch: #{current_key} vs #{new_key}"
+      end
+    end
+  end
+end

data/lib/lutaml/store/basic_store.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    class BasicStore
+      attr_reader :adapter, :cache, :monitor, :events, :config
+
+      def initialize(config_or_adapter = {})
+        if config_or_adapter.is_a?(Adapter::Base)
+          @adapter = config_or_adapter
+          @config = Config.new
+        elsif config_or_adapter.is_a?(Config)
+          @config = config_or_adapter
+          @adapter = create_adapter
+        else
+          @config = Config.new(**config_or_adapter.transform_keys(&:to_sym))
+          @adapter = create_adapter
+        end
+
+        @config.validate!
+
+        @cache = @config.cache_enabled? ? create_cache : nil
+        @monitor = @config.monitoring_enabled? ? Monitor.new : nil
+        @events = Events.new(async: @config.async_events?)
+      end
+
+      def self.from_file(file_path)
+        new(Config.from_file(file_path))
+      end
+
+      def self.from_yaml(yaml_string)
+        new(Config.from_yaml(yaml_string))
+      end
+
+      def get(key)
+        with_monitoring(:get) do
+          if @cache
+            cached_value = @cache.get(key)
+            if cached_value
+              emit_event(:get, key: key, value: cached_value, source: :cache)
+              next cached_value
+            end
+          end
+
+          value = @adapter.get(key)
+          @cache&.set(key, value) if value
+          emit_event(:get, key: key, value: value, source: :adapter)
+          value
+        end
+      end
+
+      def set(key, value)
+        with_monitoring(:set) do
+          @adapter.set(key, value)
+          @cache&.set(key, value)
+          emit_event(:set, key: key, value: value)
+        end
+      end
+
+      def delete(key)
+        with_monitoring(:delete) do
+          result = @adapter.delete(key)
+          @cache&.delete(key) if result
+          emit_event(:delete, key: key, deleted: result)
+          result
+        end
+      end
+
+      def exists?(key)
+        with_monitoring(:exists) do
+          next true if @cache&.exists?(key)
+
+          @adapter.exists?(key)
+        end
+      end
+
+      def all
+        with_monitoring(:all) do
+          @adapter.all
+        end
+      end
+
+      def clear
+        with_monitoring(:clear) do
+          @adapter.clear
+          @cache&.clear
+          emit_event(:clear)
+        end
+      end
+
+      def size
+        with_monitoring(:size) do
+          @adapter.size
+        end
+      end
+
+      def keys
+        @adapter.keys
+      end
+
+      def bulk_get(keys)
+        @adapter.bulk_get(keys)
+      end
+
+      def bulk_set(key_value_pairs)
+        @adapter.bulk_set(key_value_pairs)
+        key_value_pairs.each { |key, value| @cache&.set(key, value) }
+      end
+
+      def bulk_delete(keys)
+        result = @adapter.bulk_delete(keys)
+        keys.each { |key| @cache&.delete(key) }
+        result
+      end
+
+      def on(event, callable = nil, &block)
+        @events.on(event, callable, &block)
+      end
+
+      def off(event, listener)
+        @events.off(event, listener)
+      end
+
+      def emit_event(event, data = {})
+        @events.emit(event, data)
+      end
+
+      def stats
+        base_stats = {
+          adapter: @adapter.class.name,
+          size: size,
+          cache_enabled: !@cache.nil?,
+          monitoring_enabled: !@monitor.nil?
+        }
+
+        base_stats[:adapter_stats] = @adapter.stats
+        base_stats[:cache_stats] = @cache.stats if @cache
+        base_stats[:monitor_stats] = @monitor.stats if @monitor
+
+        base_stats
+      end
+
+      def cache_stats
+        @cache&.stats
+      end
+
+      def close
+        @events.stop if @config.async_events?
+        @adapter.close
+      end
+
+      private
+
+      def with_monitoring(operation)
+        start_time = Time.now
+        result = yield
+        record_operation(operation, Time.now - start_time, true)
+        result
+      rescue StandardError => e
+        record_operation(operation, Time.now - start_time, false)
+        @monitor&.record_error(operation, e)
+        raise
+      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
+      end
+
+      def create_cache
+        Cache.new(
+          max_size: @config.cache_max_size,
+          ttl: @config.cache_ttl
+        )
+      end
+
+      def record_operation(operation, duration, success)
+        @monitor&.record_operation(operation, duration: duration, success: success)
+      end
+    end
+  end
+end

data/lib/lutaml/store/cache.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    class Cache
+      Entry = Struct.new(:value, :timestamp, keyword_init: true)
+
+      DEFAULT_MAX_SIZE = 1000
+
+      def initialize(max_size: DEFAULT_MAX_SIZE, ttl: nil)
+        @max_size = max_size
+        @ttl = ttl
+        @data = {}
+        @access_order = []
+        @mutex = Mutex.new
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          entry = @data[key]
+          return nil unless entry
+          return nil if expired?(entry)
+
+          @access_order.delete(key)
+          @access_order << key
+          entry.value
+        end
+      end
+
+      def set(key, value)
+        @mutex.synchronize do
+          @access_order.delete(key) if @data.key?(key)
+
+          @data[key] = Entry.new(value: value, timestamp: Time.now)
+          @access_order << key
+
+          evict_lru while @data.size > @max_size
+        end
+      end
+
+      def delete(key)
+        @mutex.synchronize do
+          if @data.delete(key)
+            @access_order.delete(key)
+            true
+          else
+            false
+          end
+        end
+      end
+
+      def exists?(key)
+        @mutex.synchronize do
+          entry = @data[key]
+          entry && !expired?(entry)
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @data.clear
+          @access_order.clear
+        end
+      end
+
+      def size
+        @mutex.synchronize { @data.size }
+      end
+
+      def stats
+        @mutex.synchronize do
+          {
+            size: @data.size,
+            max_size: @max_size,
+            ttl: @ttl,
+            keys: @data.keys
+          }
+        end
+      end
+
+      def cleanup_expired
+        @mutex.synchronize do
+          expired_keys = @data.select { |_, entry| expired?(entry) }.keys
+          expired_keys.each do |key|
+            @data.delete(key)
+            @access_order.delete(key)
+          end
+          expired_keys.size
+        end
+      end
+
+      private
+
+      def expired?(entry)
+        return false unless @ttl
+
+        Time.now - entry.timestamp > @ttl
+      end
+
+      def evict_lru
+        return if @access_order.empty?
+
+        lru_key = @access_order.shift
+        @data.delete(lru_key)
+      end
+    end
+  end
+end