redis-memo 0.1.1 → 1.1.0

data/lib/redis_memo/memoize_method.rb

@@ -1,23 +1,53 @@
 # frozen_string_literal: true
+
 require_relative 'batch'
 require_relative 'future'
 require_relative 'memoizable'
 require_relative 'middleware'
 require_relative 'options'
+require_relative 'util'
 
 module RedisMemo::MemoizeMethod
+  # Core entry method for using RedisMemo to cache a method's results. When a method is memoized, all
+  # calls to the method  will first check if the results exist in the RedisMemo cache before calling
+  # the original method.
+  #
+  # @example
+  #   class Post < ApplicationRecord
+  #     extend RedisMemo::MemoizeMethod
+  #     def display_title
+  #       "#{title} by #{author.display_name}"
+  #     end
+  #     memoize_method :display_title do |post|
+  #       depends_on Post.where(id: post.id)
+  #       depends_on User.where(id: post.author_id)
+  #     end
+  #   end
+  #
+  # @param method_name [String] The name of the method to memoize
+  # @param method_id [String] Optionally, a method_id that's used to tag APM traces of RedisMemo calls.
+  # @param options [Hash] Cache options to pass to RedisMemo. These values will override the global
+  #        cache options.
+  # @option options [Integer] :expires_in The TTL for this method's cached result.
+  # @option options [Hash] :redis_options Other valid options are ones which are passed along to the Rails {RedisCacheStore}[https://api.rubyonrails.org/classes/ActiveSupport/Cache/RedisCacheStore.html].
+  # @param depends_on [block] The method's dependency block.
+  #        - The first parameter of the block is a reference to the object whose method is being memoized.
+  #        - The rest of the block parameters are the memoized method's arguments.
+  #        - Within this block, you can declare the method's dependencies as individual +RedisMemo::Memoizable+'s,
+  #          using the +RedisMemo::Dependency.depends_on+ method. RedisMemo will automatically extract dependencies
+  #          from this block and use them to compute a method's versioned cache key.
   def memoize_method(method_name, method_id: nil, **options, &depends_on)
-    method_name_without_memo = :"_redis_memo_#{method_name}_without_memo"
+    method_name_without_memoization = :"_redis_memo_#{method_name}_without_memoization"
     method_name_with_memo = :"_redis_memo_#{method_name}_with_memo"
 
-    alias_method method_name_without_memo, method_name
+    alias_method method_name_without_memoization, method_name
 
     define_method method_name_with_memo do |*args|
-      return send(method_name_without_memo, *args) if RedisMemo.without_memo?
+      return __send__(method_name_without_memoization, *args) if RedisMemo.without_memoization?
 
       dependent_memos = nil
       if depends_on
-        dependency = RedisMemo::MemoizeMethod.get_or_extract_dependencies(self, *args, &depends_on)
+        dependency = RedisMemo::MemoizeMethod.__send__(:get_or_extract_dependencies, self, *args, &depends_on)
         dependent_memos = dependency.memos
       end
 
@@ -25,7 +55,7 @@ module RedisMemo::MemoizeMethod
         self,
         case method_id
         when NilClass
-          RedisMemo::MemoizeMethod.method_id(self, method_name)
+          RedisMemo::MemoizeMethod.__send__(:method_id, self, method_name)
         when String, Symbol
           method_id
         else
@@ -34,7 +64,7 @@ module RedisMemo::MemoizeMethod
         args,
         dependent_memos,
         options,
-        method_name_without_memo,
+        method_name_without_memoization,
       )
 
       if RedisMemo::Batch.current
@@ -44,164 +74,172 @@ module RedisMemo::MemoizeMethod
 
       future.execute
     rescue RedisMemo::WithoutMemoization
-      send(method_name_without_memo, *args)
+      __send__(method_name_without_memoization, *args)
     end
 
+    ruby2_keywords method_name_with_memo
     alias_method method_name, method_name_with_memo
 
     @__redis_memo_method_dependencies ||= Hash.new
     @__redis_memo_method_dependencies[method_name] = depends_on
 
-    define_method :dependency_of do |method_name, *method_args|
-      method_depends_on = self.class.instance_variable_get(:@__redis_memo_method_dependencies)[method_name]
+    define_method :dependency_of do |other_method_name, *method_args|
+      method_depends_on = self.class.instance_variable_get(:@__redis_memo_method_dependencies)[other_method_name]
       unless method_depends_on
-        raise(
-          RedisMemo::ArgumentError,
-          "#{method_name} is not a memoized method"
+        raise RedisMemo::ArgumentError.new(
+          "#{other_method_name} is not a memoized method",
         )
       end
-      RedisMemo::MemoizeMethod.get_or_extract_dependencies(self, *method_args, &method_depends_on)
+
+      RedisMemo::MemoizeMethod.__send__(:get_or_extract_dependencies, self, *method_args, &method_depends_on)
     end
+    ruby2_keywords :dependency_of
   end
 
-  def self.method_id(ref, method_name)
-    is_class_method = ref.class == Class
-    class_name = is_class_method ? ref.name : ref.class.name
+  class << self
+    private
 
-    "#{class_name}#{is_class_method ? '::' : '#'}#{method_name}"
-  end
-
-  def self.extract_dependencies(ref, *method_args, &depends_on)
-    dependency = RedisMemo::Memoizable::Dependency.new
+    def method_id(ref, method_name)
+      is_class_method = ref.class == Class
+      class_name = is_class_method ? ref.name : ref.class.name
 
-    # Resolve the dependency recursively
-    dependency.instance_exec(ref, *method_args, &depends_on)
-    dependency
-  end
+      "#{class_name}#{is_class_method ? '::' : '#'}#{method_name}"
+    end
 
-  def self.get_or_extract_dependencies(ref, *method_args, &depends_on)
-    if RedisMemo::Cache.local_dependency_cache
-      RedisMemo::Cache.local_dependency_cache[ref.class] ||= {}
-      RedisMemo::Cache.local_dependency_cache[ref.class][depends_on] ||= {}
-      named_args = exclude_anonymous_args(depends_on, ref, method_args)
-      RedisMemo::Cache.local_dependency_cache[ref.class][depends_on][named_args] ||= extract_dependencies(ref, *method_args, &depends_on)
-    else
-      extract_dependencies(ref, *method_args, &depends_on)
+    ruby2_keywords def get_or_extract_dependencies(ref, *method_args, &depends_on)
+      if RedisMemo::Cache.local_dependency_cache
+        RedisMemo::Cache.local_dependency_cache[ref.class] ||= {}
+        RedisMemo::Cache.local_dependency_cache[ref.class][depends_on] ||= {}
+        named_args = exclude_anonymous_args(depends_on, ref, method_args)
+        RedisMemo::Cache.local_dependency_cache[ref.class][depends_on][named_args] ||= extract_dependencies(ref, *method_args, &depends_on)
+      else
+        extract_dependencies(ref, *method_args, &depends_on)
+      end
     end
-  end
 
-  # We only look at named method parameters in the dependency block in order to define its dependent
-  # memos and ignore anonymous parameters, following the convention that nil or :_ is an anonymous parameter.
-  # Example:
-  # ```
-  #    def method(param1, param2)
-  #    end
-  #
-  #    memoize_method :method do |_, _, param2|`
-  #      depends_on RedisMemo::Memoizable.new(param2: param2)
-  #    end
-  # ```
-  #  `exclude_anonymous_args(depends_on, ref, [1, 2])` returns [2]
-  def self.exclude_anonymous_args(depends_on, ref, args)
-    return [] if depends_on.parameters.empty? or args.empty?
-
-    positional_args = []
-    kwargs = {}
-    depends_on_args = [ref] + args
-    options = depends_on_args.extract_options!
-
-    # Keep track of the splat start index, and the number of positional args before and after the splat,
-    # so we can map which args belong to positional args and which args belong to the splat.
-    named_splat = false
-    splat_index = nil
-    num_positional_args_after_splat = 0
-    num_positional_args_before_splat = 0
-
-    depends_on.parameters.each_with_index do |param, i|
-      # Defined by https://github.com/ruby/ruby/blob/22b8ddfd1049c3fd1e368684c4fd03bceb041b3a/proc.c#L3048-L3059
-      case param.first
-      when :opt, :req
-        if splat_index
-          num_positional_args_after_splat += 1
+    def method_cache_keys(future_contexts)
+      memos = Array.new(future_contexts.size)
+      future_contexts.each_with_index do |(_, _, dependent_memos), i|
+        memos[i] = dependent_memos
+      end
+
+      j = 0
+      memo_checksums = RedisMemo::Memoizable.__send__(:checksums, memos.compact)
+      method_cache_key_versions = Array.new(future_contexts.size)
+      future_contexts.each_with_index do |(method_id, method_args, _), i|
+        if memos[i]
+          method_cache_key_versions[i] = [method_id, memo_checksums[j]]
+          j += 1
         else
-          num_positional_args_before_splat += 1
+          ordered_method_args = method_args.map do |arg|
+            arg.is_a?(Hash) ? RedisMemo::Util.deep_sort_hash(arg) : arg
+          end
+
+          method_cache_key_versions[i] = [
+            method_id,
+            RedisMemo::Util.checksum(ordered_method_args.to_json),
+          ]
         end
-      when :rest
-        named_splat = is_named?(param)
-        splat_index = i
-      when :key, :keyreq
-        kwargs[param.last] = options[param.last] if is_named?(param)
-      when :keyrest
-        kwargs.merge!(options) if is_named?(param)
-      else
-        raise(RedisMemo::ArgumentError, "#{param.first} argument isn't supported in the dependency block")
       end
-    end
 
-    # Determine the named positional and splat arguments after we know the # of pos. arguments before and after splat
-    after_splat_index = depends_on_args.size - num_positional_args_after_splat
-    depends_on_args.each_with_index do |arg, i|
-      # if the index is within the splat
-      if i >= num_positional_args_before_splat && i < after_splat_index
-        positional_args << arg if named_splat
-      else
-        j = i < num_positional_args_before_splat ? i : i - (after_splat_index - splat_index) - 1
-        positional_args << arg if is_named?(depends_on.parameters[j])
+      method_cache_key_versions.map do |method_id, method_cache_key_version|
+        # Example:
+        #
+        #   RedisMemo:MyModel#slow_calculation:<global cache version>:<local
+        #   cache version>
+        #
+        [
+          RedisMemo.name,
+          method_id,
+          RedisMemo::DefaultOptions.global_cache_key_version,
+          method_cache_key_version,
+        ].join(':')
       end
+    rescue RedisMemo::Cache::Rescuable
+      nil
     end
 
-    if !kwargs.empty?
-      positional_args + [kwargs]
-    elsif named_splat && !options.empty?
-      positional_args + [options]
-    else
-      positional_args
-    end
-  end
-private
-  def self.is_named?(param)
-    param.size == 2 && param.last != :_
-  end
+    ruby2_keywords def extract_dependencies(ref, *method_args, &depends_on)
+      dependency = RedisMemo::Memoizable::Dependency.new
 
-  def self.method_cache_keys(future_contexts)
-    memos = Array.new(future_contexts.size)
-    future_contexts.each_with_index do |(_, _, dependent_memos), i|
-      memos[i] = dependent_memos
+      # Resolve the dependency recursively
+      dependency.instance_exec(ref, *method_args, &depends_on)
+      dependency
     end
 
-    j = 0
-    memo_checksums = RedisMemo::Memoizable.checksums(memos.compact)
-    method_cache_key_versions = Array.new(future_contexts.size)
-    future_contexts.each_with_index do |(method_id, method_args, _), i|
-      if memos[i]
-        method_cache_key_versions[i] = [method_id, memo_checksums[j]]
-        j += 1
-      else
-        ordered_method_args = method_args.map do |arg|
-          arg.is_a?(Hash) ? RedisMemo.deep_sort_hash(arg) : arg
+    # We only look at named method parameters in the dependency block in order
+    # to define its dependent memos and ignore anonymous parameters, following
+    # the convention that nil or :_ is an anonymous parameter.
+    #
+    # Example:
+    # ```
+    #    def method(param1, param2)
+    #    end
+    #
+    #    memoize_method :method do |_, _, param2|`
+    #      depends_on RedisMemo::Memoizable.new(param2: param2)
+    #    end
+    # ```
+    #  `exclude_anonymous_args(depends_on, ref, [1, 2])` returns [2]
+    def exclude_anonymous_args(depends_on, ref, args)
+      return [] if depends_on.parameters.empty? || args.empty?
+
+      positional_args = []
+      kwargs = {}
+      depends_on_args = [ref] + args
+      options = depends_on_args.extract_options!
+
+      # Keep track of the splat start index, and the number of positional args before and after the splat,
+      # so we can map which args belong to positional args and which args belong to the splat.
+      named_splat = false
+      splat_index = nil
+      num_positional_args_after_splat = 0
+      num_positional_args_before_splat = 0
+
+      depends_on.parameters.each_with_index do |param, i|
+        # Defined by https://github.com/ruby/ruby/blob/22b8ddfd1049c3fd1e368684c4fd03bceb041b3a/proc.c#L3048-L3059
+        case param.first
+        when :opt, :req
+          if splat_index
+            num_positional_args_after_splat += 1
+          else
+            num_positional_args_before_splat += 1
+          end
+        when :rest
+          named_splat = is_named?(param)
+          splat_index = i
+        when :key, :keyreq
+          kwargs[param.last] = options[param.last] if is_named?(param)
+        when :keyrest
+          kwargs.merge!(options) if is_named?(param)
+        else
+          raise RedisMemo::ArgumentError.new("#{param.first} argument isn't supported in the dependency block")
         end
+      end
 
-        method_cache_key_versions[i] = [
-          method_id,
-          RedisMemo.checksum(ordered_method_args.to_json),
-        ]
+      # Determine the named positional and splat arguments after we know the # of pos. arguments before and after splat
+      after_splat_index = depends_on_args.size - num_positional_args_after_splat
+      depends_on_args.each_with_index do |arg, i|
+        # if the index is within the splat
+        if i >= num_positional_args_before_splat && i < after_splat_index
+          positional_args << arg if named_splat
+        else
+          j = i < num_positional_args_before_splat ? i : i - (after_splat_index - splat_index) - 1
+          positional_args << arg if is_named?(depends_on.parameters[j])
+        end
+      end
+
+      if !kwargs.empty?
+        positional_args + [kwargs]
+      elsif named_splat && !options.empty?
+        positional_args + [options]
+      else
+        positional_args
       end
     end
 
-    method_cache_key_versions.map do |method_id, method_cache_key_version|
-      # Example:
-      #
-      #   RedisMemo:MyModel#slow_calculation:<global cache version>:<local
-      #   cache version>
-      #
-      [
-        RedisMemo.name,
-        method_id,
-        RedisMemo::DefaultOptions.global_cache_key_version,
-        method_cache_key_version,
-      ].join(':')
+    def is_named?(param)
+      param.size == 2 && param.last != :_
     end
-  rescue RedisMemo::Cache::Rescuable
-    nil
   end
 end

data/lib/redis_memo/memoize_query.rb

@@ -1,121 +1,164 @@
 # frozen_string_literal: true
-require_relative 'memoize_method'
 
-if defined?(ActiveRecord)
-  # Hook into ActiveRecord to cache SQL queries and perform auto cache
-  # invalidation
-  module RedisMemo::MemoizeQuery
-    require_relative 'memoize_query/cached_select'
-    require_relative 'memoize_query/invalidation'
-    require_relative 'memoize_query/model_callback'
+require_relative 'memoize_method'
 
-    # Only editable columns will be used to create memos that are invalidatable
-    # after each record save
-    def memoize_table_column(*raw_columns, editable: true)
-      RedisMemo::MemoizeQuery.using_active_record!(self)
-      return if ENV["REDIS_MEMO_DISABLE_#{self.table_name.upcase}"] == 'true'
+# Hook into ActiveRecord to cache SQL queries and perform auto cache
+# invalidation
+module RedisMemo::MemoizeQuery
+  require_relative 'memoize_query/cached_select'
+  require_relative 'memoize_query/invalidation'
+  require_relative 'memoize_query/model_callback'
+
+  # Core entry method for using RedisMemo to cache SQL select queries on the given
+  # column names. We intercept any ActiveRecord select queries and extract the
+  # column dependencies from SQL query parameters. From the extracted dependencies
+  # and the memoized columns on the table, we determine whether or not the query
+  # should be cached on RedisMemo. Learn more in +RedisMemo::MemoizeQuery::CachedSelect+.
+  #
+  #   class User < ApplicationRecord
+  #     extend RedisMemo::MemoizeQuery
+  #     memoize_table_column :id
+  #     memoize_table_column :first_name
+  #     memoize_table_column :first_name, last_name
+  #   end
+  #
+  # On the User model, queries such as
+  #   - record.user
+  #   - User.find(user_id)
+  #   - User.where(id: user_id).first
+  #   - User.where(first_name: first_name).first
+  #   - User.where(first_name: first_name, last_name: last_name).first
+  #   - User.find_by_first_name(first_name)
+  # will first check the Redis cache for the data before hitting the SQL database;
+  # the cache results are invalidated automatically when user records are changed.
+  #
+  # Note that +memoize_table_column :first_name, last_name+ specifies that only AND queries
+  # that contain both columns will be memoized. The query +User.where(last_name: last_name)+
+  # will NOT be memoized with the given configuration.
+  #
+  # @param raw_columns [Array] A list of columns to memoize.
+  # @param editable [Boolean] Specify if the column is editable. Only editable columns
+  # will be used to create memos that are invalidatable after each record save.
+  def memoize_table_column(*raw_columns, editable: true)
+    RedisMemo::MemoizeQuery.__send__(:using_active_record!, self)
+    return if RedisMemo::DefaultOptions.disable_all
+    return if RedisMemo::DefaultOptions.model_disabled_for_caching?(self)
+
+    columns = raw_columns.map(&:to_sym).sort
+
+    RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: true) << columns if editable
+    RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: false) << columns
+
+    RedisMemo::MemoizeQuery::ModelCallback.install(self)
+    RedisMemo::MemoizeQuery::Invalidation.install(self)
+
+    unless RedisMemo::DefaultOptions.disable_cached_select
+      RedisMemo::MemoizeQuery::CachedSelect.install(ActiveRecord::Base.connection)
+    end
 
-      columns = raw_columns.map(&:to_sym).sort
+    # The code below might fail due to missing DB/table errors
+    columns.each do |column|
+      next if columns_hash.include?(column.to_s)
 
-      RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: true) << columns if editable
-      RedisMemo::MemoizeQuery.memoized_columns(self, editable_only: false) << columns
+      raise RedisMemo::ArgumentError.new("'#{name}' does not contain column '#{column}'")
+    end
 
-      RedisMemo::MemoizeQuery::ModelCallback.install(self)
-      RedisMemo::MemoizeQuery::Invalidation.install(self)
+    unless RedisMemo::DefaultOptions.model_disabled_for_caching?(self)
+      RedisMemo::MemoizeQuery::CachedSelect.enabled_models[table_name] = self
+    end
+  rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
+    # no-opts: models with memoize_table_column decleared might be loaded in
+    # rake tasks that are used to create databases
+  end
 
-      if ENV['REDIS_MEMO_DISABLE_CACHED_SELECT'] != 'true'
-        RedisMemo::MemoizeQuery::CachedSelect.install(ActiveRecord::Base.connection)
-      end
+  # Invalidates all memoized SQL queries on the given model.
+  #
+  # @param model_class [Class]
+  def self.invalidate_all(model_class)
+    RedisMemo::Tracer.trace(
+      'redis_memo.memoizable.invalidate_all',
+      model_class.name,
+    ) do
+      RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
+    end
+  end
 
-      # The code below might fail due to missing DB/table errors
-      columns.each do |column|
-        unless self.columns_hash.include?(column.to_s)
-          raise(
-            RedisMemo::ArgumentError,
-            "'#{self.name}' does not contain column '#{column}'",
-          )
-        end
-      end
+  # Invalidates all memoized SQL queries which would contain the given records.
+  #
+  # @param records [Array] ActiveRecord models to invalidate
+  def self.invalidate(*records)
+    RedisMemo::Memoizable.invalidate(
+      records.map { |record| to_memos(record) }.flatten,
+    )
+  end
 
-      unless ENV["REDIS_MEMO_DISABLE_QUERY_#{self.table_name.upcase}"] == 'true'
-        RedisMemo::MemoizeQuery::CachedSelect.enabled_models[self.table_name] = self
-      end
-    rescue ActiveRecord::NoDatabaseError, ActiveRecord::StatementInvalid
-      # no-opts: models with memoize_table_column decleared might be loaded in
-      # rake tasks that are used to create databases
-    end
+  # Class variable containing all memoized columns on all ActiveRecord models
+  @@memoized_columns = Hash.new { |h, k| h[k] = [Set.new, Set.new] }
 
-    def self.using_active_record!(model_class)
-      unless using_active_record?(model_class)
-        raise RedisMemo::ArgumentError, "'#{model_class.name}' does not use ActiveRecord"
-      end
-    end
+  # Returns the list of columns currently memoized on the model or table
+  #
+  # @param model_or_table [Class] or [String] The ActiveRecord model class or table name
+  # @param editable [Boolean] Specifies whether to retrieve only editable columns
+  def self.memoized_columns(model_or_table, editable_only: false)
+    table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
+    @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
+  end
 
-    def self.using_active_record?(model_class)
-      model_class.respond_to?(:<) && model_class < ActiveRecord::Base
+  # Creates a +RedisMemo::Memoizable+ from the given ActiveRecord model class and column values.
+  #
+  # @param model_class [Class] The ActiveRecord model class
+  # @param extra_props [Hash] Props representing any column values on the model. +extra_props+
+  #   are considered as AND conditions on the model class
+  def self.create_memo(model_class, **extra_props)
+    using_active_record!(model_class)
+
+    keys = extra_props.keys.sort
+    if !keys.empty? && !memoized_columns(model_class).include?(keys)
+      raise RedisMemo::ArgumentError.new("'#{model_class.name}' has not memoized columns: #{keys}")
     end
 
-    @@memoized_columns = Hash.new { |h, k| h[k] = [Set.new, Set.new] }
-
-    def self.memoized_columns(model_or_table, editable_only: false)
-      table = model_or_table.is_a?(Class) ? model_or_table.table_name : model_or_table
-      @@memoized_columns[table.to_sym][editable_only ? 1 : 0]
+    extra_props.each do |key, value|
+      # The data type is ensured by the database, thus we don't need to cast
+      # types here for better performance
+      column_name = key.to_s
+      extra_props[key] =
+        if model_class.defined_enums.include?(column_name)
+          enum_mapping = model_class.defined_enums[column_name]
+          # Assume a value is a converted enum if it does not exist in the
+          # enum mapping
+          (enum_mapping[value.to_s] || value).to_s
+        else
+          value.to_s
+        end
     end
 
-    # extra_props are considered as AND conditions on the model class
-    def self.create_memo(model_class, **extra_props)
-      using_active_record!(model_class)
+    RedisMemo::Memoizable.new(
+      __redis_memo_memoize_query_table_name__: model_class.table_name,
+      **extra_props,
+    )
+  end
 
-      keys = extra_props.keys.sort
-      if !keys.empty? && !memoized_columns(model_class).include?(keys)
-        raise(
-          RedisMemo::ArgumentError,
-          "'#{model_class.name}' has not memoized columns: #{keys}",
-        )
-      end
+  class << self
+    private
 
-      extra_props.each do |key, value|
-        # The data type is ensured by the database, thus we don't need to cast
-        # types here for better performance
-        column_name = key.to_s
-        extra_props[key] =
-          if model_class.defined_enums.include?(column_name)
-            enum_mapping = model_class.defined_enums[column_name]
-            # Assume a value is a converted enum if it does not exist in the
-            # enum mapping
-            (enum_mapping[value.to_s] || value).to_s
-          else
-            value.to_s
-          end
-      end
+    def using_active_record!(model_class)
+      return if using_active_record?(model_class)
 
-      RedisMemo::Memoizable.new(
-        __redis_memo_memoize_query_table_name__: model_class.table_name,
-        **extra_props,
+      raise RedisMemo::ArgumentError.new(
+        "'#{model_class.name}' does not use ActiveRecord",
       )
     end
 
-    def self.invalidate_all(model_class)
-      RedisMemo::Tracer.trace(
-        'redis_memo.memoizable.invalidate_all',
-        model_class.name,
-      ) do
-        RedisMemo::Memoizable.invalidate([model_class.redis_memo_class_memoizable])
-      end
-    end
-
-    def self.invalidate(*records)
-      RedisMemo::Memoizable.invalidate(
-        records.map { |record| to_memos(record) }.flatten,
-      )
+    def using_active_record?(model_class)
+      model_class.respond_to?(:<) && model_class < ActiveRecord::Base
     end
 
-    def self.to_memos(record)
+    def to_memos(record)
       # Invalidate memos with current values
       memos_to_invalidate = memoized_columns(record.class).map do |columns|
         props = {}
         columns.each do |column|
-          props[column] = record.send(column)
+          props[column] = record.__send__(column)
         end
 
         create_memo(record.class, **props)
@@ -138,7 +181,7 @@ if defined?(ActiveRecord)
           columns.each do |column|
             next if props.include?(column)
 
-            props[column] = record.send(column)
+            props[column] = record.__send__(column)
           end
 
           memos_to_invalidate << create_memo(record.class, **props)