Merge branch 'main' into lb/resolve-pipelining-deprecation-warnings

* main:
  Bump version for 1.2.0
  Use pipeline for migration too
  Ensure to pass the pipeline to super
  Use block parameter to pipeline in Redis#multi (#68)
  Note tested / supported versions of Redis in the Readme (#79)
  Return counter value after incrementing/decrementing
  Enum Bang setter (#82)
  Add reset to Cycle after_change callbacks
  Add example in Readme.md
  Support configuring custom keys via method invocation
  Use bundle add instead (#81)

Author: lewispb

.github/workflows/ci.yml

@@ -5,7 +5,10 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: [2.7, "3.0"]
+        redis_server: ["4", "5", "6.2"]
+        ruby: ["2.7", "3.0"]
+
+    name: Redis server ${{ matrix.redis_server }} - Ruby ${{ matrix.ruby }}
 
     steps:
       - uses: actions/checkout@v2
@@ -16,10 +19,10 @@ jobs:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
 
-      - name: Set up Redis 4
+      - name: Set up Redis ${{ matrix.redis_server }}
         uses: supercharge/[email protected]
         with:
-          redis-version: 4
+          redis-version: ${{ matrix.redis_server }}
 
       - name: Run tests
         run: bin/test

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kredis (1.1.0)
+    kredis (1.2.0)
       activesupport (>= 6.0.0)
       redis (~> 4.2)
 
@@ -153,4 +153,4 @@ DEPENDENCIES
   rake
 
 BUNDLED WITH
-   2.3.4
+   2.3.12

README.md

@@ -109,8 +109,10 @@ enum = Kredis.enum "myenum", values: %w[ one two three ], default: "one"
 true == enum.one?               # => GET myenum
 enum.value = "two"              # => SET myenum "two"
 "two" == enum.value             # => GET myenum
+enum.three!                     # => SET myenum "three"
+"three" == enum.value           # => GET myenum
 enum.value = "four"
-"two" == enum.value             # => GET myenum
+"three" == enum.value           # => GET myenum
 enum.reset                      # => DEL myenum
 "one" == enum.value             # => GET myenum
 
@@ -168,10 +170,16 @@ You can use all these structures in models:
 ```ruby
 class Person < ApplicationRecord
   kredis_list :names
-  kredis_list :names_with_custom_key, key: ->(p) { "person:#{p.id}:names_customized" }
+  kredis_list :names_with_custom_key_via_lambda, key: ->(p) { "person:#{p.id}:names_customized" }
+  kredis_list :names_with_custom_key_via_method, key: :generate_names_key
   kredis_unique_list :skills, limit: 2
   kredis_enum :morning, values: %w[ bright blue black ], default: "bright"
   kredis_counter :steps, expires_in: 1.hour
+
+  private
+    def generate_names_key
+      "key-generated-from-private-method"
+    end
 end
 
 person = Person.find(5)
@@ -195,14 +203,17 @@ end
 
 ## Installation
 
-1. Add the `kredis` gem to your Gemfile: `gem 'kredis'`
-2. Run `./bin/bundle install`
-3. Run `./bin/rails kredis:install` to add a default configuration at [`config/redis/shared.yml`](lib/install/shared.yml)
+1. Run `./bin/bundle add kredis`
+2. Run `./bin/rails kredis:install` to add a default configuration at [`config/redis/shared.yml`](lib/install/shared.yml)
 
 Additional configurations can be added under `config/redis/*.yml` and referenced when a type is created. For example, `Kredis.string("mystring", config: :strings)` would lookup `config/redis/strings.yml`.
 
 Kredis passes the configuration to `Redis.new` to establish the connection. See the [Redis documentation](https://github.com/redis/redis-rb) for other configuration options.
 
+### Redis support
+
+Kredis works with Redis server 4.0+, with the [Redis Ruby](https://github.com/redis/redis-rb) client version 4.2+.
+
 ### Setting SSL options on Redis Connections
 
 If you need to connect to Redis with SSL, the recommended approach is to set your Redis instance manually by adding an entry to the `Kredis::Connections.connections` hash. Below an example showing how to connect to Redis using Client Authentication:

lib/kredis/attributes.rb

@@ -97,6 +97,7 @@ def kredis_key_evaluated(key)
       case key
       when String then key
       when Proc   then key.call(self)
+      when Symbol then send(key)
       end
     end
 

lib/kredis/migration.rb

@@ -11,29 +11,29 @@ def initialize(config = :shared)
   end
 
   def migrate_all(key_pattern)
-    each_key_batch_matching(key_pattern) do |keys|
+    each_key_batch_matching(key_pattern) do |keys, pipeline|
       keys.each do |key|
         ids = key.scan(/\d+/).map(&:to_i)
-        migrate from: key, to: yield(key, *ids)
+        migrate from: key, to: yield(key, *ids), pipeline: pipeline
       end
     end
   end
 
-  def migrate(from:, to:)
+  def migrate(from:, to:, pipeline: nil)
     namespaced_to = Kredis.namespaced_key(to)
 
     if to.present? && from != namespaced_to
       log_migration "Migrating key #{from} to #{namespaced_to}" do
-        connection.evalsha @copy_sha, keys: [ from, namespaced_to ]
+        (pipeline || @redis).evalsha @copy_sha, keys: [ from, namespaced_to ]
       end
     else
       log_migration "Skipping blank/unaltered migration key #{from} → #{to}"
     end
   end
 
   def delete_all(key_pattern)
-    each_key_batch_matching(key_pattern) do |keys|
-      connection.del *keys
+    each_key_batch_matching(key_pattern) do |keys, pipeline|
+      pipeline.del *keys
     end
   end
 
@@ -48,11 +48,7 @@ def each_key_batch_matching(key_pattern, &block)
       cursor = "0"
       begin
         cursor, keys = @redis.scan(cursor, match: key_pattern, count: SCAN_BATCH_SIZE)
-        @redis.pipelined do |pipeline|
-          @pipeline = pipeline
-          yield keys
-          @pipeline = nil
-        end
+        @redis.multi { |pipeline| yield keys, pipeline }
       end until cursor == "0"
     end
 

lib/kredis/types/callbacks_proxy.rb

@@ -4,7 +4,7 @@ class Kredis::Types::CallbacksProxy
 
   AFTER_CHANGE_OPERATIONS = {
     Kredis::Types::Counter => %i[ increment decrement reset ],
-    Kredis::Types::Cycle => %i[ next ],
+    Kredis::Types::Cycle => %i[ next reset ],
     Kredis::Types::Enum => %i[ value= reset ],
     Kredis::Types::Flag => %i[ mark remove ],
     Kredis::Types::Hash => %i[ update delete []= remove ],

lib/kredis/types/counter.rb

@@ -4,17 +4,17 @@ class Kredis::Types::Counter < Kredis::Types::Proxying
   attr_accessor :expires_in
 
   def increment(by: 1)
-    multi do
-      set 0, ex: expires_in, nx: true
-      incrby by
-    end
+    multi do |pipeline|
+      pipeline.set 0, ex: expires_in, nx: true
+      pipeline.incrby by
+    end[-1]
   end
 
   def decrement(by: 1)
-    multi do
-      set 0, ex: expires_in, nx: true
-      decrby by
-    end
+    multi do |pipeline|
+      pipeline.set 0, ex: expires_in, nx: true
+      pipeline.decrby by
+    end[-1]
   end
 
   def value

lib/kredis/types/enum.rb

@@ -28,6 +28,7 @@ def reset
     def define_predicates_for_values
       values.each do |defined_value|
         define_singleton_method("#{defined_value}?") { value == defined_value }
+        define_singleton_method("#{defined_value}!") { self.value = defined_value }
       end
     end
 end

lib/kredis/types/list.rb

@@ -8,16 +8,16 @@ def elements
   end
   alias to_a elements
 
-  def remove(*elements)
-    types_to_strings(elements, typed).each { |element| lrem 0, element }
+  def remove(*elements, pipeline: nil)
+    types_to_strings(elements, typed).each { |element| (pipeline || proxy).lrem 0, element }
   end
 
-  def prepend(*elements)
-    lpush types_to_strings(elements, typed) if elements.flatten.any?
+  def prepend(*elements, pipeline: nil)
+    (pipeline || proxy).lpush types_to_strings(elements, typed) if elements.flatten.any?
   end
 
-  def append(*elements)
-    rpush types_to_strings(elements, typed) if elements.flatten.any?
+  def append(*elements, pipeline: nil)
+    (pipeline || proxy).rpush types_to_strings(elements, typed) if elements.flatten.any?
   end
   alias << append
 

lib/kredis/types/set.rb

@@ -8,19 +8,19 @@ def members
   end
   alias to_a members
 
-  def add(*members)
-    sadd types_to_strings(members, typed) if members.flatten.any?
+  def add(*members, pipeline: nil)
+    (pipeline || proxy).sadd types_to_strings(members, typed) if members.flatten.any?
   end
   alias << add
 
-  def remove(*members)
-    srem types_to_strings(members, typed) if members.flatten.any?
+  def remove(*members, pipeline: nil)
+    (pipeline || proxy).srem types_to_strings(members, typed) if members.flatten.any?
   end
 
   def replace(*members)
-    multi do
-      del
-      add members
+    multi do |pipeline|
+      pipeline.del
+      add members, pipeline: pipeline
     end
   end