lutaml-store 0.2.2 → 0.2.4

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

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

data/lib/lutaml/store.rb

@@ -32,6 +32,8 @@ module Lutaml
     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"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-store
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.4
 platform: ruby
 authors:
 - Ronald Tse
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-06-06 00:00:00.000000000 Z
+date: 2026-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -28,16 +28,22 @@ dependencies:
   name: rubyzip
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
 description: |
   Provides a unified store interface for Lutaml::Model objects with model registry,
   polymorphic support, composite relationships, and multiple storage backends
@@ -94,6 +100,8 @@ files:
 - lib/lutaml/store/package_transport/base.rb
 - lib/lutaml/store/package_transport/directory_transport.rb
 - lib/lutaml/store/package_transport/zip_transport.rb
+- lib/lutaml/store/predicate.rb
+- lib/lutaml/store/query.rb
 - lib/lutaml/store/storage_key.rb
 - lib/lutaml/store/version.rb
 - sig/lutaml/store.rbs