lutaml-store 0.2.1 → 0.2.4

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/package_transport/base.rb

@@ -42,6 +42,18 @@ module Lutaml
         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

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

@@ -47,7 +47,7 @@ module Lutaml
           return unless File.exist?(file_path)
 
           fmt = format_for_file(definition.metadata_file)
-          raw = File.read(file_path, encoding: "utf-8")
+          raw = read_file(file_path, fmt)
           metadata = fmt.deserialize(raw, definition.metadata_model)
           package_store.metadata = metadata
         end
@@ -60,7 +60,7 @@ module Lutaml
           content = fmt.serialize(package_store.metadata)
           file_path = File.join(path, definition.metadata_file)
           FileUtils.mkdir_p(File.dirname(file_path))
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, content, fmt)
         end
 
         def read_model_entry(base_path, entry, package_store, fmt_name)
@@ -76,7 +76,7 @@ module Lutaml
           return unless File.exist?(file_path)
 
           fmt = resolve_format(fmt_name)
-          raw = File.read(file_path, encoding: "utf-8")
+          raw = read_file(file_path, fmt)
           model = fmt.deserialize(raw, entry.model)
           package_store.add_model(model)
         end
@@ -91,8 +91,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
               case entry.layout
@@ -127,7 +127,7 @@ module Lutaml
           content = entry.layout == :grouped ? fmt.serialize_many(models) : fmt.serialize(models.first)
           file_path = File.join(base_path, entry.file)
           FileUtils.mkdir_p(File.dirname(file_path))
-          File.write(file_path, content, encoding: "utf-8")
+          write_file(file_path, content, fmt)
         end
 
         def write_directory_models(base_path, entry, models, fmt)
@@ -138,13 +138,13 @@ module Lutaml
           when :grouped
             models.group_by { |m| extract_key(m, entry) }.each do |key, group|
               file_path = File.join(dir, "#{sanitize_filename(key)}#{fmt.extension}")
-              File.write(file_path, fmt.serialize_many(group), encoding: "utf-8")
+              write_file(file_path, fmt.serialize_many(group), fmt)
             end
           else
             models.each do |model|
               key = extract_key(model, entry)
               file_path = File.join(dir, "#{sanitize_filename(key)}#{fmt.extension}")
-              File.write(file_path, fmt.serialize(model), encoding: "utf-8")
+              write_file(file_path, fmt.serialize(model), fmt)
             end
           end
         end

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

@@ -93,14 +93,19 @@ module Lutaml
             next if zip_entry.name == prefix || zip_entry.name.end_with?("/")
 
             raw = zip_entry.get_input_stream.read
-            next if raw.strip.empty?
+            next if !fmt.binary? && raw.strip.empty?
 
             begin
-              loaded = fmt.deserialize_many(raw, entry.model)
-              loaded = [loaded] unless loaded.is_a?(Array)
-              loaded.each do |m|
-                set_key_from_zip_path(m, zip_entry.name, entry, prefix)
-                package_store.add_model(m)
+              case entry.layout
+              when :grouped
+                fmt.deserialize_many(raw, entry.model).each do |m|
+                  set_key_from_zip_path(m, zip_entry.name, entry, prefix)
+                  package_store.add_model(m)
+                end
+              else
+                model = fmt.deserialize(raw, entry.model)
+                set_key_from_zip_path(model, zip_entry.name, entry, prefix)
+                package_store.add_model(model)
               end
             rescue StandardError => e
               warn "PackageStore: failed to load #{zip_entry.name}: #{e.message}"

data/lib/lutaml/store/predicate.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    module Predicate
+      class Base
+        attr_reader :field, :value
+
+        def initialize(field, value = nil)
+          @field = field.to_sym
+          @value = value
+        end
+
+        def match?(_target)
+          raise NotImplementedError
+        end
+
+        def negate
+          raise NotImplementedError
+        end
+
+        def hash_evaluable?(hash_data)
+          hash_data.key?(@field.to_s)
+        end
+
+        private
+
+        def extract(target)
+          target.is_a?(Hash) ? target[@field.to_s] : target.public_send(@field)
+        end
+      end
+
+      class Equal < Base
+        def match?(target)
+          extract(target) == @value
+        end
+
+        def negate
+          NotEqual.new(@field, @value)
+        end
+      end
+
+      class NotEqual < Base
+        def match?(target)
+          extract(target) != @value
+        end
+
+        def negate
+          Equal.new(@field, @value)
+        end
+      end
+
+      class GreaterThan < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          val > @value
+        end
+
+        def negate
+          LessThanOrEqual.new(@field, @value)
+        end
+      end
+
+      class LessThan < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          val < @value
+        end
+
+        def negate
+          GreaterThanOrEqual.new(@field, @value)
+        end
+      end
+
+      class GreaterThanOrEqual < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          val >= @value
+        end
+
+        def negate
+          LessThan.new(@field, @value)
+        end
+      end
+
+      class LessThanOrEqual < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          val <= @value
+        end
+
+        def negate
+          GreaterThan.new(@field, @value)
+        end
+      end
+
+      class Between < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          @value.cover?(val)
+        end
+
+        def negate
+          NotBetween.new(@field, @value)
+        end
+      end
+
+      class NotBetween < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          !@value.cover?(val)
+        end
+
+        def negate
+          Between.new(@field, @value)
+        end
+      end
+
+      class In < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          @value.include?(val)
+        end
+
+        def negate
+          NotIn.new(@field, @value)
+        end
+      end
+
+      class NotIn < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          !@value.include?(val)
+        end
+
+        def negate
+          In.new(@field, @value)
+        end
+      end
+
+      class Matches < Base
+        def match?(target)
+          val = extract(target)
+          return false if val.nil?
+
+          @value.match?(val.to_s)
+        end
+
+        def negate
+          NotMatches.new(@field, @value)
+        end
+      end
+
+      class NotMatches < Base
+        def match?(target)
+          val = extract(target)
+          return true if val.nil?
+
+          !@value.match?(val.to_s)
+        end
+
+        def negate
+          Matches.new(@field, @value)
+        end
+      end
+
+      class Nil < Base
+        def match?(target)
+          extract(target).nil?
+        end
+
+        def negate
+          NotNil.new(@field)
+        end
+      end
+
+      class NotNil < Base
+        def match?(target)
+          !extract(target).nil?
+        end
+
+        def negate
+          Nil.new(@field)
+        end
+      end
+
+      # ── Factory methods ──
+
+      def self.gt(field, value)
+        GreaterThan.new(field, value)
+      end
+
+      def self.lt(field, value)
+        LessThan.new(field, value)
+      end
+
+      def self.gte(field, value)
+        GreaterThanOrEqual.new(field, value)
+      end
+
+      def self.lte(field, value)
+        LessThanOrEqual.new(field, value)
+      end
+
+      def self.not(field, value)
+        NotEqual.new(field, value)
+      end
+
+      def self.matches(field, pattern)
+        Matches.new(field, pattern)
+      end
+
+      def self.nil(field)
+        Nil.new(field)
+      end
+
+      def self.not_nil(field)
+        NotNil.new(field)
+      end
+
+      def self.build_from_hash(conditions)
+        conditions.map do |field, value|
+          case value
+          when Range then Between.new(field, value)
+          when Array then In.new(field, value)
+          else Equal.new(field, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/store/query.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Store
+    # Lazy, chainable query object — inspired by ActiveRecord::Relation.
+    # Collects predicates, sort orders, limit, and offset. Nothing executes
+    # until a terminal method is called (to_a, each, first, count, etc.).
+    class Query
+      include Enumerable
+
+      attr_reader :model_class, :predicates, :orders, :limit_value, :offset_value
+
+      def initialize(store, model_class, predicates: [], orders: [],
+                     limit_value: nil, offset_value: nil)
+        @store = store
+        @model_class = model_class
+        @predicates = predicates.dup.freeze
+        @orders = orders.dup.freeze
+        @limit_value = limit_value
+        @offset_value = offset_value
+      end
+
+      # ── Chainable methods (return new Query) ──
+
+      def where(*predicates_or_conditions, **kwargs)
+        conditions = kwargs
+        new_predicates = []
+
+        predicates_or_conditions.each do |arg|
+          if arg.is_a?(Predicate::Base)
+            new_predicates << arg
+          elsif arg.is_a?(Hash)
+            conditions = conditions.merge(arg)
+          else
+            raise ArgumentError, "where accepts Predicate objects or Hash conditions, got #{arg.class}"
+          end
+        end
+
+        new_predicates.concat(Predicate.build_from_hash(conditions)) unless conditions.empty?
+        chain(predicates: @predicates + new_predicates)
+      end
+
+      def not(conditions = {}, **kwargs)
+        conditions = conditions.merge(kwargs)
+        negated = Predicate.build_from_hash(conditions).map(&:negate)
+        chain(predicates: @predicates + negated)
+      end
+
+      def order(*specs)
+        new_orders = parse_order_specs(specs)
+        chain(orders: @orders + new_orders)
+      end
+
+      def limit(count)
+        chain(limit_value: count)
+      end
+
+      def offset(count)
+        chain(offset_value: count)
+      end
+
+      def reverse_order
+        reversed = @orders.map { |o| Order.new(o.field, o.direction == :asc ? :desc : :asc) }
+        chain(orders: reversed)
+      end
+
+      # ── Terminal methods (execute the query) ──
+
+      def to_a
+        @to_a_result ||= @store.execute_query(self)
+      end
+
+      def each(&block)
+        to_a.each(&block)
+      end
+
+      def first
+        self.class.new(@store, @model_class, predicates: @predicates,
+                                             orders: @orders, limit_value: 1,
+                                             offset_value: @offset_value).to_a.first
+      end
+
+      def last
+        reversed = @orders.map { |o| Order.new(o.field, o.direction == :asc ? :desc : :asc) }
+        self.class.new(@store, @model_class, predicates: @predicates,
+                                             orders: reversed, limit_value: 1,
+                                             offset_value: @offset_value).to_a.first
+      end
+
+      def find_by(**conditions)
+        where(**conditions).first
+      end
+
+      def find_by!(**conditions)
+        result = find_by(**conditions)
+        raise ModelNotRegisteredError, "No #{@model_class} found matching #{conditions}" unless result
+
+        result
+      end
+
+      def count
+        return to_a.size if @limit_value || @offset_value
+
+        @store.count_query(self)
+      end
+
+      alias size count
+      alias length count
+
+      def exists?
+        self.class.new(@store, @model_class, predicates: @predicates,
+                                             orders: [], limit_value: 1, offset_value: nil).to_a.any?
+      end
+
+      def empty?
+        !exists?
+      end
+
+      def any?
+        exists?
+      end
+
+      def none?
+        !exists?
+      end
+
+      def one?
+        self.class.new(@store, @model_class, predicates: @predicates,
+                                             orders: [], limit_value: 2, offset_value: nil).to_a.size == 1
+      end
+
+      def many?
+        self.class.new(@store, @model_class, predicates: @predicates,
+                                             orders: [], limit_value: 2, offset_value: nil).to_a.size > 1
+      end
+
+      # ── Calculation shortcuts ──
+
+      def pluck(*fields)
+        to_a.map do |model|
+          if fields.size == 1
+            model.public_send(fields.first)
+          else
+            fields.map { |f| model.public_send(f) }
+          end
+        end
+      end
+
+      def distinct(field = nil)
+        if field
+          to_a.map { |m| m.public_send(field) }.uniq
+        else
+          to_a.uniq
+        end
+      end
+
+      def sum(field)
+        to_a.sum { |m| m.public_send(field) }
+      end
+
+      def average(field)
+        values = to_a.map { |m| m.public_send(field) }.compact
+        return 0.0 if values.empty?
+
+        values.sum.to_f / values.size
+      end
+
+      def minimum(field)
+        to_a.min_by { |m| m.public_send(field) }
+      end
+
+      def maximum(field)
+        to_a.max_by { |m| m.public_send(field) }
+      end
+
+      # ── Batch processing ──
+
+      def find_each(batch_size: 1000, &block)
+        raise ArgumentError, "find_each does not support limit/offset" if @limit_value || @offset_value
+
+        cursor = nil
+        loop do
+          batch = @store.fetch_batch(self, after: cursor, limit: batch_size)
+          break if batch.empty?
+
+          batch.each(&block)
+          cursor = @store.last_storage_key_from(batch, @model_class)
+        end
+      end
+
+      def in_batches(of: 1000)
+        raise ArgumentError, "in_batches does not support limit/offset" if @limit_value || @offset_value
+
+        cursor = nil
+        loop do
+          batch = @store.fetch_batch(self, after: cursor, limit: of)
+          break if batch.empty?
+
+          yield batch
+          cursor = @store.last_storage_key_from(batch, @model_class)
+        end
+      end
+
+      # ── Scopes ──
+
+      def apply(scope_name, *args, **kwargs)
+        scope_body = @store.scope_for(scope_name)
+        instance_exec(*args, **kwargs, &scope_body)
+      end
+
+      def inspect
+        parts = [@model_class.to_s]
+        parts << "WHERE #{@predicates.map(&:inspect).join(" AND ")}" if @predicates.any?
+        parts << "ORDER BY #{@orders.map { |o| "#{o.field} #{o.direction}" }.join(", ")}" if @orders.any?
+        parts << "LIMIT #{@limit_value}" if @limit_value
+        parts << "OFFSET #{@offset_value}" if @offset_value
+        "#<Query #{parts.join(" ")}>"
+      end
+
+      private
+
+      def chain(**overrides)
+        self.class.new(
+          @store,
+          @model_class,
+          predicates: overrides.fetch(:predicates, @predicates),
+          orders: overrides.fetch(:orders, @orders),
+          limit_value: overrides.fetch(:limit_value, @limit_value),
+          offset_value: overrides.fetch(:offset_value, @offset_value)
+        )
+      end
+
+      def parse_order_specs(specs)
+        orders = []
+        i = 0
+        while i < specs.size
+          item = specs[i]
+          case item
+          when Hash
+            item.each { |field, dir| orders << Order.new(field, dir) }
+          when Symbol, String
+            next_val = specs[i + 1]
+            if next_val.is_a?(Symbol) && %i[asc desc].include?(next_val)
+              orders << Order.new(item, next_val)
+              i += 1
+            else
+              orders << Order.new(item, :asc)
+            end
+          end
+          i += 1
+        end
+        orders
+      end
+    end
+
+    # Sort specification value object
+    Order = Struct.new(:field, :direction)
+  end
+end

data/lib/lutaml/store/storage_key.rb

@@ -18,7 +18,7 @@ module Lutaml
 
       def self.parse(string)
         str = string.to_s
-        sep = str.rindex(/(?<!:):(?!:)/)
+        sep = str.index(/(?<!:):(?!:)/)
         return new("", str) unless sep
 
         new(str[0...sep], str[sep + 1..])

data/lib/lutaml/store/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Store
-    VERSION = "0.2.1"
+    VERSION = "0.2.4"
   end
 end

data/lib/lutaml/store.rb

@@ -25,12 +25,15 @@ module Lutaml
     autoload :CompositeModelHandler, "lutaml/store/composite_model_handler"
     autoload :AttributeUpdater, "lutaml/store/attribute_updater"
     autoload :DatabaseStore, "lutaml/store/database_store"
+    autoload :FormatSerializer, "lutaml/store/format_serializer"
     autoload :PackageDefinition, "lutaml/store/package_definition"
     autoload :PackageStore, "lutaml/store/package_store"
     autoload :PackageTransport, "lutaml/store/package_transport"
     autoload :Adapter, "lutaml/store/adapter"
     autoload :StorageKey, "lutaml/store/storage_key"
     autoload :Format, "lutaml/store/format"
+    autoload :Query, "lutaml/store/query"
+    autoload :Predicate, "lutaml/store/predicate"
 
     autoload :HttpCache, "lutaml/store/http_cache"
     autoload :HttpCacheConfig, "lutaml/store/http_cache_config"