familia 1.2.1 → 2.0.0.pre.pre

data/lib/familia/redistype.rb

@@ -1,228 +0,0 @@
-# rubocop:disable all
-
-require_relative 'redistype/commands'
-require_relative 'redistype/serialization'
-
-module Familia
-
-  # RedisType - Base class for Redis data type wrappers
-  #
-  # This class provides common functionality for various Redis data types
-  # such as String, List, Set, SortedSet, and HashKey.
-  #
-  # @abstract Subclass and implement Redis data type specific methods
-  class RedisType
-    include Familia::Base
-    extend Familia::Features
-
-    @registered_types = {}
-    @valid_options = %i[class parent ttl default db key redis suffix prefix]
-    @db = nil
-
-    feature :expiration
-    feature :quantization
-
-    class << self
-      attr_reader :registered_types, :valid_options, :has_relations
-      attr_accessor :parent
-      attr_writer :db, :uri
-    end
-
-    module ClassMethods
-      # To be called inside every class that inherits RedisType
-      # +methname+ is the term used for the class and instance methods
-      # that are created for the given +klass+ (e.g. set, list, etc)
-      def register(klass, methname)
-        Familia.ld "[#{self}] Registering #{klass} as #{methname.inspect}"
-
-        @registered_types[methname] = klass
-      end
-
-      def db(val = nil)
-        @db = val unless val.nil?
-        @db || parent&.db
-      end
-
-      def uri(val = nil)
-        @uri = val unless val.nil?
-        @uri || (parent ? parent.uri : Familia.uri)
-      end
-
-      def inherited(obj)
-        Familia.trace :REDISTYPE, nil, "#{obj} is my kinda type", caller(1..1) if Familia.debug?
-        obj.db = db
-        obj.ttl = ttl # method added via Features::Expiration
-        obj.uri = uri
-        obj.parent = self
-        super(obj)
-      end
-
-      def valid_keys_only(opts)
-        opts.select { |k, _| RedisType.valid_options.include? k }
-      end
-
-      def has_relations?
-        @has_relations ||= false
-      end
-    end
-    extend ClassMethods
-
-    attr_reader :keystring, :parent, :opts
-    attr_writer :dump_method, :load_method
-
-    # +keystring+: If parent is set, this will be used as the suffix
-    # for rediskey. Otherwise this becomes the value of the key.
-    # If this is an Array, the elements will be joined.
-    #
-    # Options:
-    #
-    # :class => A class that responds to Familia.load_method and
-    # Familia.dump_method. These will be used when loading and
-    # saving data from/to redis to unmarshal/marshal the class.
-    #
-    # :parent => The Familia object that this redistype object belongs
-    # to. This can be a class that includes Familia or an instance.
-    #
-    # :ttl => the time to live in seconds. When not nil, this will
-    # set the redis expire for this key whenever #save is called.
-    # You can also call it explicitly via #update_expiration.
-    #
-    # :default => the default value (String-only)
-    #
-    # :db => the redis database to use (ignored if :redis is used).
-    #
-    # :redis => an instance of Redis.
-    #
-    # :key => a hardcoded key to use instead of the deriving the from
-    # the name and parent (e.g. a derived key: customer:custid:secret_counter).
-    #
-    # :suffix => the suffix to use for the key (e.g. 'scores' in customer:custid:scores).
-    # :prefix => the prefix to use for the key (e.g. 'customer' in customer:custid:scores).
-    #
-    # Connection precendence: uses the redis connection of the parent or the
-    # value of opts[:redis] or Familia.redis (in that order).
-    def initialize(keystring, opts = {})
-      #Familia.ld " [initializing] #{self.class} #{opts}"
-      @keystring = keystring
-      @keystring = @keystring.join(Familia.delim) if @keystring.is_a?(Array)
-
-      # Remove all keys from the opts that are not in the allowed list
-      @opts = opts || {}
-      @opts = RedisType.valid_keys_only(@opts)
-
-      # Apply the options to instance method setters of the same name
-      @opts.each do |k, v|
-        # Bewarde logging :parent instance here implicitly calls #to_s which for
-        # some classes could include the identifier which could still be nil at
-        # this point. This would result in a Familia::Problem being raised. So
-        # to be on the safe-side here until we have a better understanding of
-        # the issue, we'll just log the class name for each key-value pair.
-        Familia.ld " [setting] #{k} #{v.class}"
-        send(:"#{k}=", v) if respond_to? :"#{k}="
-      end
-
-      init if respond_to? :init
-    end
-
-    def redis
-      return @redis if @redis
-
-      parent? ? parent.redis : Familia.redis(opts[:db])
-    end
-
-    # Produces the full Redis key for this object.
-    #
-    # @return [String] The full Redis key.
-    #
-    # This method determines the appropriate Redis key based on the context of the RedisType object:
-    #
-    # 1. If a hardcoded key is set in the options, it returns that key.
-    # 2. For instance-level RedisType objects, it uses the parent instance's rediskey method.
-    # 3. For class-level RedisType objects, it uses the parent class's rediskey method.
-    # 4. For standalone RedisType objects, it uses the keystring as the full Redis key.
-    #
-    # For class-level RedisType objects (parent_class? == true):
-    # - The suffix is optional and used to differentiate between different types of objects.
-    # - If no suffix is provided, the class's default suffix is used (via the self.suffix method).
-    # - If a nil suffix is explicitly passed, it won't appear in the resulting Redis key.
-    # - Passing nil as the suffix is how class-level RedisType objects are created without
-    #   the global default 'object' suffix.
-    #
-    # @example Instance-level RedisType
-    #   user_instance.some_redistype.rediskey  # => "user:123:some_redistype"
-    #
-    # @example Class-level RedisType
-    #   User.some_redistype.rediskey  # => "user:some_redistype"
-    #
-    # @example Standalone RedisType
-    #   RedisType.new("mykey").rediskey  # => "mykey"
-    #
-    # @example Class-level RedisType with explicit nil suffix
-    #   User.rediskey("123", nil)  # => "user:123"
-    #
-    def rediskey
-      # Return the hardcoded key if it's set. This is useful for
-      # support legacy keys that aren't derived in the same way.
-      return opts[:key] if opts[:key]
-
-      if parent_instance?
-        # This is an instance-level redistype object so the parent instance's
-        # rediskey method is defined in Familia::Horreum::InstanceMethods.
-        parent.rediskey(keystring)
-      elsif parent_class?
-        # This is a class-level redistype object so the parent class' rediskey
-        # method is defined in Familia::Horreum::ClassMethods.
-        parent.rediskey(keystring, nil)
-      else
-        # This is a standalone RedisType object where it's keystring
-        # is the full redis key.
-        keystring
-      end
-    end
-
-    def class?
-      !@opts[:class].to_s.empty? && @opts[:class].is_a?(Familia)
-    end
-
-    def parent_instance?
-      parent.is_a?(Familia::Horreum)
-    end
-
-    def parent_class?
-      parent.is_a?(Class) && parent <= Familia::Horreum
-    end
-
-    def parent?
-      parent_class? || parent_instance?
-    end
-
-    def parent
-      @opts[:parent]
-    end
-
-    def db
-      @opts[:db] || self.class.db
-    end
-
-    def uri
-      @opts[:uri] || self.class.uri
-    end
-
-    def dump_method
-      @dump_method || self.class.dump_method
-    end
-
-    def load_method
-      @load_method || self.class.load_method
-    end
-
-    include Commands
-    include Serialization
-  end
-
-  require_relative 'redistype/types/list'
-  require_relative 'redistype/types/unsorted_set'
-  require_relative 'redistype/types/sorted_set'
-  require_relative 'redistype/types/hashkey'
-  require_relative 'redistype/types/string'
-end

data/lib/familia/tools.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-module Familia
-  module Tools
-    extend self
-    def move_keys(filter, source_uri, target_uri, &each_key)
-      raise "Source and target are the same (#{target_uri})" if target_uri == source_uri
-
-      Familia.connect target_uri
-      source_keys = Familia.redis(source_uri).keys(filter)
-      puts "Moving #{source_keys.size} keys from #{source_uri} to #{target_uri} (filter: #{filter})"
-      source_keys.each_with_index do |key, idx|
-        type = Familia.redis(source_uri).type key
-        ttl = Familia.redis(source_uri).ttl key
-        if source_uri.host == target_uri.host && source_uri.port == target_uri.port
-          Familia.redis(source_uri).move key, target_uri.db
-        else
-          case type
-          when 'string'
-            Familia.redis(source_uri).get key
-          when 'list'
-            Familia.redis(source_uri).lrange key, 0, -1
-          when 'set'
-            Familia.redis(source_uri).smembers key
-          else
-            raise Familia::Problem, "unknown key type: #{type}"
-          end
-          raise 'Not implemented'
-        end
-        yield(idx, type, key, ttl) unless each_key.nil?
-      end
-    end
-
-    # Use the return value from each_key as the new key name
-    def rename(filter, source_uri, target_uri = nil, &each_key)
-      target_uri ||= source_uri
-      move_keys filter, source_uri, target_uri if source_uri != target_uri
-      source_keys = Familia.redis(source_uri).keys(filter)
-      puts "Renaming #{source_keys.size} keys from #{source_uri} (filter: #{filter})"
-      source_keys.each_with_index do |key, idx|
-        Familia.trace :RENAME1, Familia.redis(source_uri), "#{key}", ''
-        type = Familia.redis(source_uri).type key
-        ttl = Familia.redis(source_uri).ttl key
-        newkey = yield(idx, type, key, ttl) unless each_key.nil?
-        Familia.trace :RENAME2, Familia.redis(source_uri), "#{key} -> #{newkey}", caller(1..1).first
-        Familia.redis(source_uri).renamenx key, newkey
-      end
-    end
-
-    def get_any(keyname, uri = nil)
-      type = Familia.redis(uri).type keyname
-      case type
-      when 'string'
-        Familia.redis(uri).get keyname
-      when 'list'
-        Familia.redis(uri).lrange(keyname, 0, -1) || []
-      when 'set'
-        Familia.redis(uri).smembers(keyname) || []
-      when 'zset'
-        Familia.redis(uri).zrange(keyname, 0, -1) || []
-      when 'hash'
-        Familia.redis(uri).hgetall(keyname) || {}
-      else
-        nil
-      end
-    end
-  end
-end

data/lib/redis_middleware.rb

@@ -1,109 +0,0 @@
-# frozen_string_literal: true
-
-# RedisLogger is RedisClient middleware.
-#
-# This middleware addresses the need for detailed Redis command logging, which
-# was removed from the redis-rb gem due to performance concerns. However, in
-# many development and debugging scenarios, the ability to log Redis commands
-# can be invaluable.
-#
-# @example Enable Redis command logging
-#   RedisLogger.logger = Logger.new(STDOUT)
-#   RedisClient.register(RedisLogger)
-#
-# @see https://github.com/redis-rb/redis-client?tab=readme-ov-file#instrumentation-and-middlewares
-#
-# @note While there were concerns about the performance impact of logging in
-#   the redis-rb gem, this middleware is designed to be optional and can be
-#   easily enabled or disabled as needed. The performance impact is minimal
-#   when logging is disabled, and the benefits during development and debugging
-#   often outweigh the slight performance cost when enabled.
-module RedisLogger
-  @logger = nil
-
-  class << self
-    # Gets/sets the logger instance used by RedisLogger.
-    # @return [Logger, nil] The current logger instance or nil if not set.
-    attr_accessor :logger
-  end
-
-  # Logs the Redis command and its execution time.
-  #
-  # This method is called for each Redis command when the middleware is active.
-  # It logs the command and its execution time only if a logger is set.
-  #
-  # @param command [Array] The Redis command and its arguments.
-  # @param redis_config [Hash] The configuration options for the Redis
-  #   connection.
-  # @return [Object] The result of the Redis command execution.
-  #
-  # @note The performance impact of this logging is negligible when no logger
-  #   is set, as it quickly returns control to the Redis client. When a logger
-  #   is set, the minimal overhead is often offset by the valuable insights
-  #   gained during development and debugging.
-  def call(command, redis_config)
-    return yield unless RedisLogger.logger
-
-    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
-    result = yield
-    duration = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond) - start
-    RedisLogger.logger.debug("Redis: #{command.inspect} (#{duration}µs)")
-    result
-  end
-end
-
-# RedisCommandCounter is RedisClient middleware.
-#
-# This middleware counts the number of Redis commands executed. It can be
-# useful for performance monitoring and debugging, allowing you to track
-# the volume of Redis operations in your application.
-#
-# @example Enable Redis command counting
-#   RedisCommandCounter.reset
-#   RedisClient.register(RedisCommandCounter)
-#
-# @see https://github.com/redis-rb/redis-client?tab=readme-ov-file#instrumentation-and-middlewares
-module RedisCommandCounter
-  @count = 0
-  @mutex = Mutex.new
-
-  class << self
-    # Gets the current count of Redis commands executed.
-    # @return [Integer] The number of Redis commands executed.
-    attr_reader :count
-
-    # Resets the command count to zero.
-    # This method is thread-safe.
-    # @return [Integer] The reset count (always 0).
-    def reset
-      @mutex.synchronize { @count = 0 }
-    end
-
-    # Increments the command count.
-    # This method is thread-safe.
-    # @return [Integer] The new count after incrementing.
-    def increment
-      @mutex.synchronize { @count += 1 }
-    end
-
-    def count_commands
-      start_count = count
-      yield
-      end_count = count
-      end_count - start_count
-    end
-  end
-
-  # Counts the Redis command and delegates its execution.
-  #
-  # This method is called for each Redis command when the middleware is active.
-  # It increments the command count and then yields to execute the actual command.
-  #
-  # @param command [Array] The Redis command and its arguments.
-  # @param redis_config [Hash] The configuration options for the Redis connection.
-  # @return [Object] The result of the Redis command execution.
-  def call(command, redis_config)
-    RedisCommandCounter.increment
-    yield
-  end
-end

data/try/20_redis_type_try.rb

@@ -1,70 +0,0 @@
-
-require_relative '../lib/familia'
-require_relative './test_helpers'
-
-
-@limiter1 = Limiter.new :requests
-
-
-## Redis Types are unique per instance of a Familia class
-@a = Bone.new 'atoken1', :name1
-@b = Bone.new 'atoken2', :name2
-p [@a.object_id, @b.object_id]
-p [@a.owners.parent.class, @b.owners.parent.class]
-p [@a.owners.parent.object_id, @b.owners.parent.object_id]
-p [@a.owners.rediskey, @b.owners.rediskey]
-p [@a.token, @b.token]
-p [@a.name, @b.name]
-@a.owners.rediskey.eql?(@b.owners.rediskey)
-#=> false
-
-## Redis Types are frozen
-@a.owners.frozen?
-#=> true
-
-## Limiter#qstamp
-@limiter1.counter.qstamp(10.minutes, '%H:%M', 1302468980)
-##=> '20:50'
-
-## Redis Types can be stored to quantized stamp suffix
-@limiter1.counter.rediskey
-##=> "v1:limiter:requests:counter:20:50"
-
-## Limiter#qstamp as a number
-@limiter2 = Limiter.new :requests
-p [@limiter1.ttl, @limiter2.ttl]
-p [@limiter1.counter.parent.ttl, @limiter2.counter.parent.ttl]
-@limiter2.counter.qstamp(10.minutes, pattern: nil, time: 1302468980)
-#=> 1302468600
-
-## Redis Types can be stored to quantized numeric suffix. This
-## tryouts is disabled b/c `RedisType#rediskey` takes no args
-## and relies on the `class Limiter` definition in test_helpers.rb
-## for the `:quantize` option. The quantized suffix for the Limiter
-## class is `'%H:%M'` so its redis keys will always look like that.
-@limiter2.counter.rediskey
-##=> "v1:limiter:requests:counter:1302468600"
-
-## Increment counter
-@limiter1.counter.delete!
-@limiter1.counter.increment
-#=> 1
-
-## Check counter ttl
-@limiter1.counter.ttl
-#=> 3600.0
-
-## Check limiter ttl
-@limiter1.ttl
-#=> 1800.0
-
-## Check ttl for a different instance
-## (this exists to make sure options are cloned for each instance)
-@limiter3 = Limiter.new :requests
-@limiter3.counter.ttl
-#=> 3600.0
-
-## Check realttl
-sleep 1 # Redis ttls are in seconds so we can't wait any less time than this (without mocking)
-@limiter1.counter.realttl
-#=> 3600-1

data/try/91_json_bug_try.rb

@@ -1,86 +0,0 @@
-# try/91_json_bug_try.rb
-
-require_relative '../lib/familia'
-require_relative './test_helpers'
-
-Familia.debug = false
-
-# Define a simple model with fields that should handle JSON data
-class JsonTest < Familia::Horreum
-  identifier :id
-  field :id
-  field :config      # This should be able to store Hash objects
-  field :tags        # This should be able to store Array objects
-  field :simple      # This should store simple strings as-is
-end
-
-# Create an instance with JSON data
-@test_obj = JsonTest.new
-@test_obj.id = "json_test_1"
-
-## Test 1: Store a Hash - should serialize to JSON automatically
-@test_obj.config = { theme: "dark", notifications: true, settings: { volume: 80 } }
-@test_obj.config.class
-#=> Hash
-
-## Test 2: Store an Array - should serialize to JSON automatically
-@test_obj.tags = ["ruby", "redis", "json", "familia"]
-@test_obj.tags.class
-#=> Array
-
-## Test 3: Store a simple string - should remain as string
-@test_obj.simple = "just a string"
-@test_obj.simple.class
-#=> String
-
-## Save the object - this should call serialize_value and use to_json
-@test_obj.save
-#=> true
-
-## Verify what's actually stored in Redis (raw)
-raw_data = @test_obj.hgetall
-p [:plop, @test_obj]
-puts "Raw Redis data:"
-raw_data
-#=> {"id"=>"json_test_1", "config"=>"{\"theme\":\"dark\",\"notifications\":true,\"settings\":{\"volume\":80}}", "tags"=>"[\"ruby\",\"redis\",\"json\",\"familia\"]", "simple"=>"just a string", "key"=>"json_test_1"}
-
-## BUG: After refresh, JSON data comes back as strings instead of parsed objects
-@test_obj.refresh!
-
-## Test 4: Hash should be deserialized back to Hash
-puts "Config after refresh:"
-puts @test_obj.config.inspect
-puts "Config class: "
-[@test_obj.config.class, @test_obj.config.inspect]
-#=> [Hash, "{:theme=>\"dark\", :notifications=>true, :settings=>{:volume=>80}}"]
-
-## Test 5: Array should be deserialized back to Array
-puts "Tags after refresh:"
-puts @test_obj.tags.inspect
-puts "Tags class: #{@test_obj.tags.class}"
-@test_obj.tags.inspect
-@test_obj.tags.class
-#=> ["ruby", "redis", "json", "familia"]
-#=> Array
-
-## Test 6: Simple string should remain a string (this works correctly)
-puts "Simple after refresh:"
-puts @test_obj.simple.inspect
-puts "Simple class: #{@test_obj.simple.class}"
-@test_obj.simple.inspect
-@test_obj.simple.class
-#=> "just a string"
-#=> String
-
-## Demonstrate the asymmetry:
-puts "\n=== ASYMMETRY DEMONSTRATION ==="
-puts "Before save: config is #{@test_obj.config.class}"
-@test_obj.config = { example: "data" }
-puts "After assignment: config is #{@test_obj.config.class}"
-@test_obj.save
-puts "After save: config is still #{@test_obj.config.class}"
-@test_obj.refresh!
-puts "After refresh: config is now #{@test_obj.config.class}!"
-
-## Clean up
-@test_obj.destroy!