familia 2.0.0 → 2.1.0

data/lib/familia/data_type/types/unsorted_set.rb

@@ -87,113 +87,9 @@ module Familia
     end
     alias remove remove_element # deprecated
 
-    # Returns the intersection of this set with one or more other sets.
-    # @param other_sets [Array<UnsortedSet, String>] Other sets (as UnsortedSet instances or raw keys)
-    # @return [Array] Deserialized members present in all sets
-    def intersection(*other_sets)
-      keys = extract_keys(other_sets)
-      elements = dbclient.sinter(dbkey, *keys)
-      deserialize_values(*elements)
-    end
-    alias inter intersection
-
-    # Returns the union of this set with one or more other sets.
-    # @param other_sets [Array<UnsortedSet, String>] Other sets (as UnsortedSet instances or raw keys)
-    # @return [Array] Deserialized members present in any of the sets
-    def union(*other_sets)
-      keys = extract_keys(other_sets)
-      elements = dbclient.sunion(dbkey, *keys)
-      deserialize_values(*elements)
-    end
-
-    # Returns the difference of this set minus one or more other sets.
-    # @param other_sets [Array<UnsortedSet, String>] Other sets (as UnsortedSet instances or raw keys)
-    # @return [Array] Deserialized members present in this set but not in any other sets
-    def difference(*other_sets)
-      keys = extract_keys(other_sets)
-      elements = dbclient.sdiff(dbkey, *keys)
-      deserialize_values(*elements)
-    end
-    alias diff difference
-
-    # Checks membership for multiple values at once.
-    # @param values [Array] Values to check for membership
-    # @return [Array<Boolean>] Array of booleans indicating membership for each value
-    def member_any?(*values)
-      values = values.flatten
-      serialized = values.map { |v| serialize_value(v) }
-      dbclient.smismember(dbkey, *serialized)
-    end
-    alias members? member_any?
-
-    # Iterates over set members using cursor-based iteration.
-    # @param cursor [Integer] Starting cursor position (default: 0)
-    # @param match [String, nil] Optional pattern to filter members
-    # @param count [Integer, nil] Optional hint for number of elements to return per call
-    # @return [Array<Integer, Array>] Two-element array: [new_cursor, deserialized_members]
-    def scan(cursor = 0, match: nil, count: nil)
-      opts = {}
-      opts[:match] = match if match
-      opts[:count] = count if count
-
-      new_cursor, elements = dbclient.sscan(dbkey, cursor, **opts)
-      [new_cursor.to_i, deserialize_values(*elements)]
-    end
-
-    # Returns the cardinality of the intersection without retrieving members.
-    # More memory-efficient than intersection when only the count is needed.
-    # @param other_sets [Array<UnsortedSet, String>] Other sets (as UnsortedSet instances or raw keys)
-    # @param limit [Integer] Stop counting after reaching this limit (0 = no limit)
-    # @return [Integer] Number of elements in the intersection
-    def intercard(*other_sets, limit: 0)
-      keys = extract_keys(other_sets)
-      all_keys = [dbkey, *keys]
-      if limit.positive?
-        dbclient.sintercard(all_keys.size, *all_keys, limit: limit)
-      else
-        dbclient.sintercard(all_keys.size, *all_keys)
-      end
-    end
-    alias intersection_cardinality intercard
-
-    # Stores the intersection of this set with other sets into a destination key.
-    # @param destination [UnsortedSet, String] Destination set (as UnsortedSet instance or raw key)
-    # @param other_sets [Array<UnsortedSet, String>] Other sets to intersect with
-    # @return [Integer] Number of elements in the resulting set
-    def interstore(destination, *other_sets)
-      dest_key = extract_key(destination)
-      keys = extract_keys(other_sets)
-      result = dbclient.sinterstore(dest_key, dbkey, *keys)
-      update_expiration
-      result
-    end
-    alias intersection_store interstore
-
-    # Stores the union of this set with other sets into a destination key.
-    # @param destination [UnsortedSet, String] Destination set (as UnsortedSet instance or raw key)
-    # @param other_sets [Array<UnsortedSet, String>] Other sets to union with
-    # @return [Integer] Number of elements in the resulting set
-    def unionstore(destination, *other_sets)
-      dest_key = extract_key(destination)
-      keys = extract_keys(other_sets)
-      result = dbclient.sunionstore(dest_key, dbkey, *keys)
-      update_expiration
-      result
-    end
-    alias union_store unionstore
-
-    # Stores the difference of this set minus other sets into a destination key.
-    # @param destination [UnsortedSet, String] Destination set (as UnsortedSet instance or raw key)
-    # @param other_sets [Array<UnsortedSet, String>] Other sets to subtract
-    # @return [Integer] Number of elements in the resulting set
-    def diffstore(destination, *other_sets)
-      dest_key = extract_key(destination)
-      keys = extract_keys(other_sets)
-      result = dbclient.sdiffstore(dest_key, dbkey, *keys)
-      update_expiration
-      result
+    def intersection *setkeys
+      # TODO
     end
-    alias difference_store diffstore
 
     def pop
       dbclient.spop dbkey
@@ -219,22 +115,6 @@ module Familia
     end
     alias random sampleraw
 
-    private
-
-    # Extracts the database key from a set reference.
-    # @param set_ref [UnsortedSet, String] An UnsortedSet instance or raw key string
-    # @return [String] The database key
-    def extract_key(set_ref)
-      set_ref.respond_to?(:dbkey) ? set_ref.dbkey : set_ref.to_s
-    end
-
-    # Extracts database keys from an array of set references.
-    # @param set_refs [Array<UnsortedSet, String>] Array of UnsortedSet instances or raw keys
-    # @return [Array<String>] Array of database keys
-    def extract_keys(set_refs)
-      set_refs.flatten.map { |s| extract_key(s) }
-    end
-
     Familia::DataType.register self, :set
     Familia::DataType.register self, :unsorted_set
   end

data/lib/familia/features/schema_validation.rb

@@ -0,0 +1,139 @@
+# lib/familia/features/schema_validation.rb
+#
+# frozen_string_literal: true
+
+module Familia
+  module Features
+    # Adds JSON schema validation methods to Horreum models.
+    # Schemas are loaded from external files via SchemaRegistry.
+    #
+    # This feature provides instance-level validation against JSON schemas,
+    # enabling data integrity checks before persistence or during API operations.
+    #
+    # Example:
+    #
+    #   class Customer < Familia::Horreum
+    #     feature :schema_validation
+    #     identifier_field :custid
+    #     field :custid
+    #     field :email
+    #   end
+    #
+    #   # With schema at schemas/customer.json
+    #   customer = Customer.new(custid: 'c1', email: 'invalid')
+    #   customer.valid_against_schema?      # => false
+    #   customer.schema_validation_errors   # => [...]
+    #   customer.validate_against_schema!   # raises SchemaValidationError
+    #
+    # Schema Loading:
+    #
+    # Schemas are loaded by SchemaRegistry based on class names. Configure
+    # schema loading before enabling this feature:
+    #
+    #   # Convention-based loading
+    #   Familia.schema_path = 'schemas/models'
+    #   # Loads schemas/models/customer.json for Customer class
+    #
+    #   # Explicit mapping
+    #   Familia.schemas = { 'Customer' => 'schemas/customer.json' }
+    #
+    # Validation Behavior:
+    #
+    # - Returns true/valid if no schema is defined for the class
+    # - Uses json_schemer gem for validation when available
+    # - Falls back to null validation (always passes) if gem not installed
+    #
+    # Integration Patterns:
+    #
+    #   # Validate before save
+    #   class Order < Familia::Horreum
+    #     feature :schema_validation
+    #
+    #     def save
+    #       validate_against_schema!
+    #       super
+    #     end
+    #   end
+    #
+    #   # Conditional validation
+    #   class User < Familia::Horreum
+    #     feature :schema_validation
+    #
+    #     def save
+    #       if self.class.schema_defined?
+    #         return false unless valid_against_schema?
+    #       end
+    #       super
+    #     end
+    #   end
+    #
+    # Error Handling:
+    #
+    # The validate_against_schema! method raises SchemaValidationError with
+    # detailed error information:
+    #
+    #   begin
+    #     customer.validate_against_schema!
+    #   rescue Familia::SchemaValidationError => e
+    #     e.errors  # => [{ 'data_pointer' => '/email', 'type' => 'format', ... }]
+    #   end
+    #
+    # @see Familia::SchemaRegistry for schema loading and configuration
+    # @see Familia::SchemaValidationError for error details
+    #
+    module SchemaValidation
+      Familia::Base.add_feature self, :schema_validation
+
+      def self.included(base)
+        Familia.trace :LOADED, self, base if Familia.debug?
+        base.extend(ClassMethods)
+      end
+
+      # Class-level schema access methods
+      module ClassMethods
+        # Get the JSON schema for this class
+        # @return [Hash, nil] the parsed schema or nil if not defined
+        def schema
+          Familia::SchemaRegistry.schema_for(name)
+        end
+
+        # Check if a schema is defined for this class
+        # @return [Boolean]
+        def schema_defined?
+          Familia::SchemaRegistry.schema_defined?(name)
+        end
+      end
+
+      # Get the schema for this instance's class
+      # @return [Hash, nil]
+      def schema
+        self.class.schema
+      end
+
+      # Check if the current state validates against the schema
+      # @return [Boolean] true if valid or no schema defined
+      def valid_against_schema?
+        return true unless self.class.schema_defined?
+
+        Familia::SchemaRegistry.validate(self.class.name, to_h)[:valid]
+      end
+
+      # Get validation errors for the current state
+      # @return [Array<Hash>] array of error objects (empty if valid)
+      def schema_validation_errors
+        return [] unless self.class.schema_defined?
+
+        Familia::SchemaRegistry.validate(self.class.name, to_h)[:errors]
+      end
+
+      # Validate current state or raise SchemaValidationError
+      # @return [true] if valid
+      # @raise [SchemaValidationError] if validation fails
+      def validate_against_schema!
+        return true unless self.class.schema_defined?
+
+        Familia::SchemaRegistry.validate!(self.class.name, to_h)
+      end
+    end
+  end
+end