redis-memo 0.1.4 → 1.0.0

data/lib/redis_memo/memoize_query/cached_select.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-#
+##
 # Inspect a SQL's AST to memoize SELECT statements
 #
 # As Rails applies additional logic on top of the rows returned from the
@@ -94,6 +94,12 @@ class RedisMemo::MemoizeQuery::CachedSelect
 
   @@enabled_models = {}
 
+  # Thread locals to exchange information between RedisMemo and ActiveRecord
+  RedisMemo::ThreadLocalVar.define :arel
+  RedisMemo::ThreadLocalVar.define :substitues
+  RedisMemo::ThreadLocalVar.define :arel_bind_params
+
+  # @return [Hash] models enabled for caching
   def self.enabled_models
     @@enabled_models
   end
@@ -107,9 +113,11 @@ class RedisMemo::MemoizeQuery::CachedSelect
 
       memoize_method(
         :exec_query,
-        method_id: proc do |_, sql, *args|
-          sql.gsub(/(\$\d+)/, '?')      # $1 -> ?
-             .gsub(/((, *)*\?)+/, '?')  # (?, ?, ? ...) -> (?)
+        method_id: proc do |_, sql, *_args|
+          # replace $1 with ?,
+          # and (?, ?, ? ...) with (?)
+          sql.gsub(/(\$\d+)/, '?')
+             .gsub(/((, *)*\?)+/, '?')
         end,
       ) do |_, sql, _, binds, **|
         depends_on RedisMemo::MemoizeQuery::CachedSelect.current_query_bind_params
@@ -123,7 +131,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
               # In activerecord >= 6, a bind could be an actual database value
               bind
             end
-          end
+          end,
         )
       end
     end
@@ -152,12 +160,18 @@ class RedisMemo::MemoizeQuery::CachedSelect
     end
   end
 
+  # Extract bind params from the query by inspecting the SQL's AST recursively
+  # The bind params will be passed into the local thread variables
+  # See +extract_bind_params_recurse+ for how to extract binding params recursively
+  #
+  # @param sql [String] SQL query
+  # @return [Boolean] indicating whether a query should be cached
   def self.extract_bind_params(sql)
-    ast = Thread.current[THREAD_KEY_AREL]&.ast
+    ast = RedisMemo::ThreadLocalVar.arel&.ast
     return false unless ast.is_a?(Arel::Nodes::SelectStatement)
     return false unless ast.to_sql == sql
 
-    Thread.current[THREAD_KEY_SUBSTITUTES] ||= {}
+    RedisMemo::ThreadLocalVar.substitues ||= {}
     # Iterate through the Arel AST in a Depth First Search
     bind_params = extract_bind_params_recurse(ast)
     return false unless bind_params
@@ -165,48 +179,51 @@ class RedisMemo::MemoizeQuery::CachedSelect
     bind_params.uniq!
     return false unless bind_params.memoizable?
 
-    Thread.current[THREAD_KEY_AREL_BIND_PARAMS] = bind_params
+    RedisMemo::ThreadLocalVar.arel_bind_params = bind_params
     true
   end
 
   def self.current_query_bind_params
-    Thread.current[THREAD_KEY_AREL_BIND_PARAMS]
+    RedisMemo::ThreadLocalVar.arel_bind_params
   end
 
   def self.current_query=(arel)
-    Thread.current[THREAD_KEY_AREL] = arel
+    RedisMemo::ThreadLocalVar.arel = arel
   end
 
   def self.current_substitutes=(substitutes)
-    Thread.current[THREAD_KEY_SUBSTITUTES] = substitutes
+    RedisMemo::ThreadLocalVar.substitues = substitutes
   end
 
   def self.reset_current_query
-    Thread.current[THREAD_KEY_AREL] = nil
-    Thread.current[THREAD_KEY_SUBSTITUTES] = nil
-    Thread.current[THREAD_KEY_AREL_BIND_PARAMS] = nil
+    RedisMemo::ThreadLocalVar.arel = nil
+    RedisMemo::ThreadLocalVar.substitues = nil
+    RedisMemo::ThreadLocalVar.arel_bind_params = nil
   end
 
   def self.with_new_query_context
-    prev_arel = Thread.current[THREAD_KEY_AREL]
-    prev_substitutes = Thread.current[THREAD_KEY_SUBSTITUTES]
-    prev_bind_params = Thread.current[THREAD_KEY_AREL_BIND_PARAMS]
+    prev_arel = RedisMemo::ThreadLocalVar.arel
+    prev_substitutes = RedisMemo::ThreadLocalVar.substitues
+    prev_bind_params = RedisMemo::ThreadLocalVar.arel_bind_params
     RedisMemo::MemoizeQuery::CachedSelect.reset_current_query
 
     yield
   ensure
-    Thread.current[THREAD_KEY_AREL] = prev_arel
-    Thread.current[THREAD_KEY_SUBSTITUTES] = prev_substitutes
-    Thread.current[THREAD_KEY_AREL_BIND_PARAMS] = prev_bind_params
+    RedisMemo::ThreadLocalVar.arel = prev_arel
+    RedisMemo::ThreadLocalVar.substitues = prev_substitutes
+    RedisMemo::ThreadLocalVar.arel_bind_params = prev_bind_params
   end
 
-  private
-
   # A pre-order Depth First Search
   #
   # Note: Arel::Nodes#each returns a list in post-order, and it does not step
   # into Union nodes. So we're implementing our own DFS
+  #
+  # @param node [Arel::Nodes::Node]
+  #
+  # @return [RedisMemo::MemoizeQuery::CachedSelect::BindParams]
   def self.extract_bind_params_recurse(node)
+    # rubocop: disable Lint/NonLocalExitFromIterator
     bind_params = BindParams.new
 
     case node
@@ -229,7 +246,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
       return unless binding_relation
 
       rights = node.right.is_a?(Array) ? node.right : [node.right]
-      substitutes = Thread.current[THREAD_KEY_SUBSTITUTES]
+      substitutes = RedisMemo::ThreadLocalVar.substitues
 
       rights.each do |right|
         case right
@@ -257,11 +274,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
           }
         else
           bind_params = bind_params.union(extract_bind_params_recurse(right))
-          if bind_params
-            next
-          else
-            return
-          end
+          return if !bind_params
         end
       end
 
@@ -281,7 +294,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
           return if core.wheres.empty? || binding_relation.nil?
         when Arel::Nodes::TableAlias
           bind_params = bind_params.union(
-            extract_bind_params_recurse(source_node.left)
+            extract_bind_params_recurse(source_node.left),
           )
 
           return unless bind_params
@@ -292,7 +305,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
         # Binds wheres before havings
         core.wheres.each do |where|
           bind_params = bind_params.union(
-            extract_bind_params_recurse(where)
+            extract_bind_params_recurse(where),
           )
 
           return unless bind_params
@@ -300,7 +313,7 @@ class RedisMemo::MemoizeQuery::CachedSelect
 
         core.havings.each do |having|
           bind_params = bind_params.union(
-            extract_bind_params_recurse(having)
+            extract_bind_params_recurse(having),
           )
 
           return unless bind_params
@@ -313,13 +326,13 @@ class RedisMemo::MemoizeQuery::CachedSelect
       bind_params
     when Arel::Nodes::Grouping
       # Inline SQL
-      return if node.expr.is_a?(Arel::Nodes::SqlLiteral)
-
       extract_bind_params_recurse(node.expr)
+    when Arel::Nodes::LessThan, Arel::Nodes::LessThanOrEqual, Arel::Nodes::GreaterThan, Arel::Nodes::GreaterThanOrEqual, Arel::Nodes::NotEqual
+      bind_params
     when Arel::Nodes::And
       node.children.each do |child|
         bind_params = bind_params.product(
-          extract_bind_params_recurse(child)
+          extract_bind_params_recurse(child),
         )
 
         return unless bind_params
@@ -329,28 +342,33 @@ class RedisMemo::MemoizeQuery::CachedSelect
     when Arel::Nodes::Union, Arel::Nodes::Or
       [node.left, node.right].each do |child|
         bind_params = bind_params.union(
-          extract_bind_params_recurse(child)
+          extract_bind_params_recurse(child),
         )
 
         return unless bind_params
       end
 
       bind_params
-
-    when Arel::Nodes::NotEqual
-      # We don't cache based on NOT queries (where.not) because it is unbound
-      # but we memoize queries with NOT and other bound queries, so we return the original bind_params
-      return bind_params
     else
       # Not yet supported
-      return
+      nil
     end
+    # rubocop: enable Lint/NonLocalExitFromIterator
   end
 
+  # Retrieve the model info from the table node
+  # table node is an Arel::Table object, e.g. <Arel::Table @name="sites" ...>
+  # and we can retrieve the model info by inspecting thhe table name
+  # See +RedisMemo::MemoizeQuery::memoize_table_column+ for how to construct enabled_models
+  #
+  # @params table_node [Arel::Table]
   def self.extract_binding_relation(table_node)
     enabled_models[table_node.try(:name)]
   end
 
+  #
+  # Identify whether the node has filter condition
+  #
   class NodeHasFilterCondition
     def self.===(node)
       case node
@@ -367,9 +385,4 @@ class RedisMemo::MemoizeQuery::CachedSelect
       end
     end
   end
-
-  # Thread locals to exchange information between RedisMemo and ActiveRecord
-  THREAD_KEY_AREL = :__redis_memo_memoize_query_cached_select_arel__
-  THREAD_KEY_SUBSTITUTES = :__redis_memo_memoize_query_cached_select_substitues__
-  THREAD_KEY_AREL_BIND_PARAMS = :__redis_memo_memoize_query_cached_select_arel_bind_params__
 end

data/lib/redis_memo/memoize_query/cached_select/connection_adapter.rb

@@ -2,7 +2,7 @@
 
 class RedisMemo::MemoizeQuery::CachedSelect
   module ConnectionAdapter
-    def cacheable_query(*args)
+    ruby2_keywords def cacheable_query(*args)
       query, binds = super(*args)
 
       # Persist the arel object to StatementCache#execute
@@ -11,24 +11,24 @@ class RedisMemo::MemoizeQuery::CachedSelect
       [query, binds]
     end
 
-    def exec_query(*args)
+    ruby2_keywords def exec_query(*args)
       # An Arel AST in Thread local is set prior to supported query methods
-      if !RedisMemo.without_memo? &&
+      if !RedisMemo.without_memoization? &&
           RedisMemo::MemoizeQuery::CachedSelect.extract_bind_params(args[0])
         # [Reids $model Load] $sql $binds
         RedisMemo::DefaultOptions.logger&.info(
           "[Redis] \u001b[36;1m#{args[1]} \u001b[34;1m#{args[0]}\u001b[0m #{
-            args[2].map { |bind| [bind.name, bind.value_for_database]}
-          }"
+            args[2].map { |bind| [bind.name, bind.value_for_database] }
+          }",
         )
 
         super(*args)
       else
-        RedisMemo.without_memo { super(*args) }
+        RedisMemo.without_memoization { super(*args) }
       end
     end
 
-    def select_all(*args)
+    ruby2_keywords def select_all(*args)
       if args[0].is_a?(Arel::SelectManager)
         RedisMemo::MemoizeQuery::CachedSelect.current_query = args[0]
       end

data/lib/redis_memo/memoize_query/invalidation.rb

@@ -17,28 +17,29 @@ class RedisMemo::MemoizeQuery::Invalidation
         @redis_memo_class_memoizable ||= RedisMemo::MemoizeQuery.create_memo(self)
       end
 
-      %i(delete decrement! increment!).each do |method_name|
+      %i[delete decrement! increment!].each do |method_name|
         alias_method :"without_redis_memo_invalidation_#{method_name}", method_name
 
         define_method method_name do |*args|
-          result = send(:"without_redis_memo_invalidation_#{method_name}", *args)
+          result = __send__(:"without_redis_memo_invalidation_#{method_name}", *args)
 
           RedisMemo::MemoizeQuery.invalidate(self)
 
           result
         end
+        ruby2_keywords method_name
       end
     end
 
     # Methods that won't trigger model callbacks
     # https://guides.rubyonrails.org/active_record_callbacks.html#skipping-callbacks
-    %i(
+    %i[
       decrement_counter
       delete_all delete_by
       increment_counter
       touch_all
       update_column update_columns update_all update_counters
-    ).each do |method_name|
+    ].each do |method_name|
       # Example: Model.update_all
       rewrite_default_method(
         model_class,
@@ -56,27 +57,27 @@ class RedisMemo::MemoizeQuery::Invalidation
       )
     end
 
-    %i(
+    %i[
       insert insert! insert_all insert_all!
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_insert_method(
         model_class,
         method_name,
       )
     end
 
-    %i(
+    %i[
       upsert upsert_all
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_upsert_method(
         model_class,
         method_name,
       )
     end
 
-    %i(
+    %i[
       import import!
-    ).each do |method_name|
+    ].each do |method_name|
       rewrite_import_method(
         model_class,
         method_name,
@@ -116,8 +117,6 @@ class RedisMemo::MemoizeQuery::Invalidation
     result
   end
 
-  private
-
   #
   # There’s no good way to perform fine-grind cache invalidation when
   # operations are bulk update operations such as update_all, and delete_all
@@ -127,17 +126,18 @@ class RedisMemo::MemoizeQuery::Invalidation
   #
   def self.rewrite_default_method(model_class, klass, method_name, class_method:)
     methods = class_method ? :methods : :instance_methods
-    return unless klass.send(methods).include?(method_name)
+    return unless klass.__send__(methods).include?(method_name)
 
     klass = klass.singleton_class if class_method
     klass.class_eval do
       alias_method :"#{method_name}_without_redis_memo_invalidation", method_name
 
       define_method method_name do |*args|
-        result = send(:"#{method_name}_without_redis_memo_invalidation", *args)
+        result = __send__(:"#{method_name}_without_redis_memo_invalidation", *args)
         RedisMemo::MemoizeQuery.invalidate_all(model_class)
         result
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -149,9 +149,10 @@ class RedisMemo::MemoizeQuery::Invalidation
 
       define_method method_name do |*args, &blk|
         RedisMemo::MemoizeQuery::Invalidation.invalidate_new_records(model_class) do
-          send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
+          __send__(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
         end
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -169,7 +170,7 @@ class RedisMemo::MemoizeQuery::Invalidation
           # HEAD (6.1.3)
           conflict_target: nil,
         ) do
-          send(
+          __send__(
             :"#{method_name}_without_redis_memo_invalidation",
             attributes,
             unique_by: unique_by,
@@ -216,9 +217,10 @@ class RedisMemo::MemoizeQuery::Invalidation
           records: records,
           conflict_target: conflict_target,
         ) do
-          send(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
+          __send__(:"#{method_name}_without_redis_memo_invalidation", *args, &blk)
         end
       end
+      ruby2_keywords method_name
     end
   end
 
@@ -228,7 +230,7 @@ class RedisMemo::MemoizeQuery::Invalidation
     records.each do |record|
       conditions = {}
       conflict_target.each do |column|
-        conditions[column] = record.send(column)
+        conditions[column] = record.__send__(column)
       end
       if or_chain
         or_chain = or_chain.or(model_class.where(conditions))
@@ -245,7 +247,7 @@ class RedisMemo::MemoizeQuery::Invalidation
       'redis_memo.memoize_query.invalidation',
       "#{__method__}##{model_class.name}",
     ) do
-      RedisMemo.without_memo do
+      RedisMemo.without_memoization do
         model_class.where(
           model_class.arel_table[model_class.primary_key].gt(target_id),
         ).to_a
@@ -260,7 +262,7 @@ class RedisMemo::MemoizeQuery::Invalidation
       'redis_memo.memoize_query.invalidation',
       "#{__method__}##{model_class.name}",
     ) do
-      RedisMemo.without_memo { relation.reload }
+      RedisMemo.without_memoization { relation.reload }
     end
   end
 end

data/lib/redis_memo/memoize_query/memoize_table_column.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'memoize_method'
 
 module RedisMemo::MemoizeQuery

data/lib/redis_memo/middleware.rb

@@ -9,7 +9,7 @@ class RedisMemo::Middleware
     result = nil
 
     RedisMemo::Cache.with_local_cache do
-      RedisMemo.with_max_connection_attempts(ENV['REDIS_MEMO_MAX_ATTEMPTS_PER_REQUEST']&.to_i) do
+      RedisMemo.with_max_connection_attempts(RedisMemo::DefaultOptions.max_connection_attempts) do
         result = @app.call(env)
       end
     end