kredis 1.3.0.1 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6042f4320cf89f8b0eae1ce4c8daa61ee6821775b7fdeab02777673a25b2cba1
-  data.tar.gz: 67121a89444ffd7f8e0a1636fc6651a2851bbc5b63514a23413136bca2abd22d
+  metadata.gz: c7b578a8b9d0b956e519c324d7ba9dd6036124637801366d9f1a2719a7d340d5
+  data.tar.gz: a4bc7d1a74540a7bd41691105833123bffd27ff32f07b01ce82986820d6068e3
 SHA512:
-  metadata.gz: 81888671af0fb781788d890640142da0f36bf03589d628ec2aaeca1d86608d9602282a9b9955e0c496cd47be01d4f4e3e42d47ac9d9414949ca635c2768177b8
-  data.tar.gz: eb7f0f1896bf2c27c4fa5630d43db65c8fcf183de9be5709146a3d06d183afdc33873f705a57dbbea5c58c2ca826758a82bd84ef81dfd320ca1d2a5c1c5eef1a
+  metadata.gz: 5ca284918aa9079b5265f1603a9ff33c7fe6f562b4cf76a97ce571542a7dccb9265d2d94441b578570729e415d0ea1adf29786612a31635660cebe82917172df
+  data.tar.gz: 569e06a45f6696800372a6f11a953e12267faf009596767366a860c0f6f691c40668d5a0e94ea7cd0c9bf09370870bca209a3e9081d8f0489be79fce64864ae1

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2020 Basecamp
+Copyright (c) 2020-2025 37signals LLC
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -17,4 +17,4 @@ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -21,11 +21,11 @@ integer.value = 5  # => SET myinteger "5"
 5 == integer.value # => GET myinteger
 
 decimal = Kredis.decimal "mydecimal" # accuracy!
-decimal.value = "%.47f" % (1.0/10) # => SET mydecimal "0.10000000000000000555111512312578270211815834045"
+decimal.value = "%.47f" % (1.0 / 10) # => SET mydecimal "0.10000000000000000555111512312578270211815834045"
 BigDecimal("0.10000000000000000555111512312578270211815834045e0") == decimal.value # => GET mydecimal
 
 float = Kredis.float "myfloat" # speed!
-float.value = 1.0/10 # => SET myfloat "0.1"
+float.value = 1.0 / 10 # => SET myfloat "0.1"
 0.1 == float.value # => GET myfloat
 
 boolean = Kredis.boolean "myboolean"
@@ -48,11 +48,13 @@ There are data structures for counters, enums, flags, lists, unique lists, sets,
 list = Kredis.list "mylist"
 list << "hello world!"               # => RPUSH mylist "hello world!"
 [ "hello world!" ] == list.elements  # => LRANGE mylist 0, -1
+list.clear                           # => DEL mylist
 
-integer_list = Kredis.list "myintegerlist", typed: :integer
-integer_list.append([ 1, 2, 3 ])        # => RPUSH myintegerlist "1" "2" "3"
-integer_list << 4                       # => RPUSH myintegerlist "4"
-[ 1, 2, 3, 4 ] == integer_list.elements # => LRANGE myintegerlist 0 -1
+integer_list = Kredis.list "myintegerlist", typed: :integer, default: [ 1, 2, 3 ] # => EXISTS? myintegerlist, RPUSH myintegerlist "1" "2" "3"
+integer_list.append([ 4, 5, 6 ])                                                  # => RPUSH myintegerlist "4" "5" "6"
+integer_list << 7                                                                 # => RPUSH myintegerlist "7"
+[ 1, 2, 3, 4, 5, 6, 7 ] == integer_list.elements                                  # => LRANGE myintegerlist 0 -1
+integer_list.clear                                                                # => DEL myintegerlist
 
 unique_list = Kredis.unique_list "myuniquelist"
 unique_list.append(%w[ 2 3 4 ])                # => LREM myuniquelist 0, "2" + LREM myuniquelist 0, "3" + LREM myuniquelist 0, "4"  + RPUSH myuniquelist "2", "3", "4"
@@ -61,12 +63,22 @@ unique_list.append([])
 unique_list << "5"                             # => LREM myuniquelist 0, "5" + RPUSH myuniquelist "5"
 unique_list.remove(3)                          # => LREM myuniquelist 0, "3"
 [ "4", "2", "1", "5" ] == unique_list.elements # => LRANGE myuniquelist 0, -1
+unique_list.clear                              # => DEL myuniquelist
+
+ordered_set = Kredis.ordered_set "myorderedset"
+ordered_set.append(%w[ 2 3 4 ])                # => ZADD myorderedset 1646131025.4953232 2 1646131025.495326 3 1646131025.4953272 4
+ordered_set.prepend(%w[ 1 2 3 4 ])             # => ZADD myorderedset -1646131025.4957051 1 -1646131025.495707 2 -1646131025.4957082 3 -1646131025.4957092 4
+ordered_set.append([])
+ordered_set << "5"                             # => ZADD myorderedset 1646131025.4960442 5
+ordered_set.remove(3)                          # => ZREM myorderedset 3
+[ "4", "2", "1", "5" ] == ordered_set.elements # => ZRANGE myorderedset 0 -1
 
 set = Kredis.set "myset", typed: :datetime
 set.add(DateTime.tomorrow, DateTime.yesterday)           # => SADD myset "2021-02-03 00:00:00 +0100" "2021-02-01 00:00:00 +0100"
 set << DateTime.tomorrow                                 # => SADD myset "2021-02-03 00:00:00 +0100"
 2 == set.size                                            # => SCARD myset
 [ DateTime.tomorrow, DateTime.yesterday ] == set.members # => SMEMBERS myset
+set.clear                                                # => DEL myset
 
 hash = Kredis.hash "myhash"
 hash.update("key" => "value", "key2" => "value2")     # => HSET myhash "key", "value", "key2", "value2"
@@ -94,6 +106,7 @@ counter.increment by: 2         # => SET mycounter 0 EX 5 NX + INCRBY "mycounter
 2 == counter.value              # => GET "mycounter"
 sleep 6.seconds
 0 == counter.value              # => GET "mycounter"
+counter.reset                   # => DEL mycounter
 
 cycle = Kredis.cycle "mycycle", values: %i[ one two three ]
 :one == cycle.value             # => GET mycycle
@@ -103,6 +116,7 @@ cycle.next                      # => GET mycycle + SET mycycle 2
 :three == cycle.value           # => GET mycycle
 cycle.next                      # => GET mycycle + SET mycycle 0
 :one == cycle.value             # => GET mycycle
+cycle.reset                     # => DEL mycycle
 
 enum = Kredis.enum "myenum", values: %w[ one two three ], default: "one"
 "one" == enum.value             # => GET myenum
@@ -153,18 +167,22 @@ sleep 0.5.seconds
 true == flag.marked?            #=> EXISTS myflag
 sleep 0.6.seconds
 false == flag.marked?           #=> EXISTS myflag
-```
-
-And using structures on a different than the default `shared` redis instance, relying on `config/redis/secondary.yml`:
 
-```ruby
-one_string = Kredis.string "mystring"
-two_string = Kredis.string "mystring", config: :secondary
-
-one_string.value = "just on shared"
-two_string.value != one_string.value
+limiter = Kredis.limiter "mylimit", limit: 3, expires_in: 5.seconds
+0 == limiter.value              # => GET "limiter"
+limiter.poke                    # => SET limiter 0 NX + INCRBY limiter 1
+limiter.poke                    # => SET limiter 0 NX + INCRBY limiter 1
+false == limiter.exceeded?      # => GET "limiter"
+limiter.poke                    # => SET limiter 0 NX + INCRBY limiter 1
+true == limiter.exceeded?       # => GET "limiter"
+sleep 6
+limiter.poke                    # => SET limiter 0 NX + INCRBY limiter 1
+limiter.poke                    # => SET limiter 0 NX + INCRBY limiter 1
+false == limiter.exceeded?      # => GET "limiter"
 ```
 
+### Models
+
 You can use all these structures in models:
 
 ```ruby
@@ -189,6 +207,29 @@ person.morning.value = "blue"                        # => SET people:5:morning
 true == person.morning.blue?                         # => GET people:5:morning
 ```
 
+### Default values
+
+You can set a default value for all types. For example:
+
+```ruby
+list = Kredis.list "favorite_colors", default: [ "red", "green", "blue" ]
+
+# or, in a model
+class Person < ApplicationRecord
+  kredis_string :name, default: "Unknown"
+  kredis_list :favorite_colors, default: [ "red", "green", "blue" ]
+end
+```
+
+There's a performance overhead to consider though. When you first read or write an attribute in a model, Kredis will
+check if the underlying Redis key exists, while watching for concurrent changes, and if it does not,
+write the specified default value.
+
+This means that using default values in a typical Rails app additional Redis calls (WATCH, EXISTS, UNWATCH) will be
+executed for each Kredis attribute with a default value read or written during a request.
+
+### Callbacks
+
 You can also define `after_change` callbacks that trigger on mutations:
 
 ```ruby
@@ -201,6 +242,18 @@ class Person < ApplicationRecord
 end
 ```
 
+### Multiple Redis servers
+
+And using structures on a different than the default `shared` redis instance, relying on `config/redis/secondary.yml`:
+
+```ruby
+one_string = Kredis.string "mystring"
+two_string = Kredis.string "mystring", config: :secondary
+
+one_string.value = "just on shared"
+two_string.value != one_string.value
+```
+
 ## Installation
 
 1. Run `./bin/bundle add kredis`
@@ -210,9 +263,11 @@ Additional configurations can be added under `config/redis/*.yml` and referenced
 
 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.
 
+If you don't have `config/redis/shared.yml` (or use another named configuration), Kredis will default to look in env for `REDIS_URL`, then fallback to a default URL of `redis://127.0.0.1:6379/0`.
+
 ### Redis support
 
-Kredis works with Redis server 4.0+, with the [Redis Ruby](https://github.com/redis/redis-rb) client version 4.2+.
+Kredis works with Redis server 4.0+, with the [Redis Ruby](https://github.com/redis/redis-rb) client version 4.2+. Redis Cluster is not supported.
 
 ### Setting SSL options on Redis Connections
 
@@ -220,14 +275,14 @@ If you need to connect to Redis with SSL, the recommended approach is to set you
 
 ```ruby
 Kredis::Connections.connections[:shared] = Redis.new(
-  url: ENV['REDIS_URL'],
+  url: ENV["REDIS_URL"],
   ssl_params: {
     cert_store: OpenSSL::X509::Store.new.tap { |store|
-      store.add_file(Rails.root.join('config', 'ca_cert.pem').to_s)
+      store.add_file(Rails.root.join("config", "ca_cert.pem").to_s)
     },
 
     cert: OpenSSL::X509::Certificate.new(File.read(
-      Rails.root.join('config', 'client.crt')
+      Rails.root.join("config", "client.crt")
     )),
 
     key: OpenSSL::PKey::RSA.new(
@@ -251,6 +306,29 @@ config.kredis.connector = ->(config) { SomeRedisProxy.new(config) }
 
 By default Kredis will use `Redis.new(config)`.
 
+## Development
+
+A development console is available by running `bin/console`.
+
+From there, you can experiment with Kredis. e.g.
+
+```erb
+>> str = Kredis.string "mystring"
+  Kredis  (0.1ms)  Connected to shared
+=>
+#<Kredis::Types::Scalar:0x0000000134c7d938
+...
+>> str.value = "hello, world"
+  Kredis Proxy (2.4ms)  SET mystring ["hello, world"]
+=> "hello, world"
+>> str.value
+```
+
+Run tests with `bin/test`.
+
+[`debug`](https://github.com/ruby/debug) can be used in the development console and in the test suite by inserting a
+breakpoint, e.g. `debugger`.
+
 ## License
 
 Kredis is released under the [MIT License](https://opensource.org/licenses/MIT).

data/lib/install/install.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 yaml_path = Rails.root.join("config/redis/shared.yml")
 unless yaml_path.exist?
   say "Adding `config/redis/shared.yml`"

data/lib/kredis/attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kredis::Attributes
   extend ActiveSupport::Concern
 
@@ -6,52 +8,56 @@ module Kredis::Attributes
       kredis_connection_with __method__, name, key, config: config, after_change: after_change
     end
 
-    def kredis_string(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_string(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_integer(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_integer(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_decimal(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_decimal(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_datetime(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_datetime(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_flag(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_flag(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
 
       define_method("#{name}?") do
         send(name).marked?
       end
     end
 
-    def kredis_float(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_float(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
     def kredis_enum(name, key: nil, values:, default:, config: :shared, after_change: nil)
       kredis_connection_with __method__, name, key, values: values, default: default, config: config, after_change: after_change
     end
 
-    def kredis_json(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_json(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
+    end
+
+    def kredis_list(name, key: nil, default: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, default: default, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_list(name, key: nil, typed: :string, config: :shared, after_change: nil)
-      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
+    def kredis_unique_list(name, limit: nil, key: nil, default: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, default: default, limit: limit, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared, after_change: nil)
-      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config, after_change: after_change
+    def kredis_set(name, key: nil, default: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, default: default, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_set(name, key: nil, typed: :string, config: :shared, after_change: nil)
-      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
+    def kredis_ordered_set(name, limit: nil, default: nil, key: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, default: default, limit: limit, typed: typed, config: config, after_change: after_change
     end
 
     def kredis_slot(name, key: nil, config: :shared, after_change: nil)
@@ -62,16 +68,20 @@ module Kredis::Attributes
       kredis_connection_with __method__, name, key, available: available, config: config, after_change: after_change
     end
 
-    def kredis_counter(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_counter(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
+    end
+
+    def kredis_limiter(name, limit:, key: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, limit: limit, config: config, after_change: after_change, expires_in: expires_in
     end
 
-    def kredis_hash(name, key: nil, typed: :string, config: :shared, after_change: nil)
-      kredis_connection_with __method__, name, key, typed: typed, config: config, after_change: after_change
+    def kredis_hash(name, key: nil, default: nil, typed: :string, config: :shared, after_change: nil)
+      kredis_connection_with __method__, name, key, default: default, typed: typed, config: config, after_change: after_change
     end
 
-    def kredis_boolean(name, key: nil, config: :shared, after_change: nil, expires_in: nil)
-      kredis_connection_with __method__, name, key, config: config, after_change: after_change, expires_in: expires_in
+    def kredis_boolean(name, key: nil, default: nil, config: :shared, after_change: nil, expires_in: nil)
+      kredis_connection_with __method__, name, key, default: default, config: config, after_change: after_change, expires_in: expires_in
     end
 
     private
@@ -84,6 +94,7 @@ module Kredis::Attributes
           if instance_variable_defined?(ivar_symbol)
             instance_variable_get(ivar_symbol)
           else
+            options[:default] = kredis_default_evaluated(options[:default]) if options[:default]
             new_type = Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options)
             instance_variable_set ivar_symbol,
               after_change ? enrich_after_change_with_record_access(new_type, after_change) : new_type
@@ -102,7 +113,7 @@ module Kredis::Attributes
     end
 
     def kredis_key_for_attribute(name)
-      "#{self.class.name.tableize.gsub("/", ":")}:#{extract_kredis_id}:#{name}"
+      "#{self.class.name.tableize.tr("/", ":")}:#{extract_kredis_id}:#{name}"
     end
 
     def extract_kredis_id
@@ -115,4 +126,12 @@ module Kredis::Attributes
       when Symbol then Kredis::Types::CallbacksProxy.new(type, ->(_) { send(original_after_change) })
       end
     end
+
+    def kredis_default_evaluated(default)
+      case default
+      when Proc   then Proc.new { default.call(self) }
+      when Symbol then send(default)
+      else default
+      end
+    end
 end

data/lib/kredis/connections.rb

@@ -1,14 +1,23 @@
+# frozen_string_literal: true
+
 require "redis"
 
 module Kredis::Connections
+  DEFAULT_REDIS_URL     = "redis://127.0.0.1:6379/0"
+  DEFAULT_REDIS_TIMEOUT = 1
+
   mattr_accessor :connections, default: Hash.new
   mattr_accessor :configurator
   mattr_accessor :connector, default: ->(config) { Redis.new(config) }
 
   def configured_for(name)
-    connections[name] ||= begin
-      Kredis.instrument :meta, message: "Connected to #{name}" do
+    connections[name] ||= Kredis.instrument :meta, message: "Connected to #{name}" do
+      if configurator.root.join("config/redis/#{name}.yml").exist?
         connector.call configurator.config_for("redis/#{name}")
+      elsif name == :shared
+        Redis.new url: ENV.fetch("REDIS_URL", DEFAULT_REDIS_URL), timeout: DEFAULT_REDIS_TIMEOUT
+      else
+        raise "No configuration found for #{name}"
       end
     end
   end

data/lib/kredis/default_values.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kredis::DefaultValues
+  extend ActiveSupport::Concern
+
+  prepended do
+    attr_writer :default
+
+    proxying :watch, :unwatch, :exists?
+
+    def default
+      case @default
+      when Proc   then @default.call
+      when Symbol then send(@default)
+      else @default
+      end
+    end
+
+    private
+      def set_default
+        raise NotImplementedError, "Kredis type #{self.class} needs to define #set_default"
+      end
+  end
+
+  def initialize(...)
+    super
+
+    if default
+      watch do
+        set_default unless exists?
+
+        unwatch
+      end
+    end
+  end
+end

data/lib/kredis/log_subscriber.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/log_subscriber"
 
 class Kredis::LogSubscriber < ActiveSupport::LogSubscriber
@@ -15,7 +17,7 @@ class Kredis::LogSubscriber < ActiveSupport::LogSubscriber
 
   private
     def formatted_in(color, event, type: nil)
-      color "  Kredis #{type} (#{event.duration.round(1)}ms)  #{event.payload[:message]}", color, true
+      color "  Kredis #{type} (#{event.duration.round(1)}ms)  #{event.payload[:message]}", color, bold: true
     end
 end
 

data/lib/kredis/migration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/delegation"
 
 class Kredis::Migration
@@ -33,10 +35,10 @@ class Kredis::Migration
   def delete_all(*key_patterns)
     log_migration "DELETE ALL #{key_patterns.inspect}" do
       if key_patterns.length > 1
-        @redis.del *key_patterns
+        @redis.del(*key_patterns)
       else
         each_key_batch_matching(key_patterns.first) do |keys, pipeline|
-          pipeline.del *keys
+          pipeline.del(*keys)
         end
       end
     end

data/lib/kredis/namespace.rb

@@ -1,12 +1,31 @@
+# frozen_string_literal: true
+
 module Kredis::Namespace
-  def namespace=(namespace)
-    Thread.current[:kredis_namespace] = namespace
-  end
+  attr_accessor :global_namespace
 
   def namespace
-    Thread.current[:kredis_namespace]
+    if global_namespace
+      if value = thread_namespace
+        "#{global_namespace}:#{value}"
+      else
+        global_namespace
+      end
+    else
+      thread_namespace
+    end
+  end
+
+  def thread_namespace
+    Thread.current[:kredis_thread_namespace]
   end
 
+  def thread_namespace=(value)
+    Thread.current[:kredis_thread_namespace] = value
+  end
+
+  # Backward compatibility
+  alias_method :namespace=, :thread_namespace=
+
   def namespaced_key(key)
     namespace ? "#{namespace}:#{key}" : key
   end

data/lib/kredis/railtie.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 class Kredis::Railtie < ::Rails::Railtie
   config.kredis = ActiveSupport::OrderedOptions.new
 
   initializer "kredis.testing" do
     ActiveSupport.on_load(:active_support_test_case) do
-      parallelize_setup { |worker| Kredis.namespace = "test-#{worker}" }
+      parallelize_setup { |worker| Kredis.global_namespace = [ Kredis.global_namespace, :test, worker ].compact.join("-") }
       teardown { Kredis.clear_all }
     end
   end

data/lib/kredis/type/boolean.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Kredis
+  module Type
+    class Boolean < ActiveModel::Type::Boolean
+      def serialize(value)
+        super ? 1 : 0
+      end
+    end
+  end
+end

data/lib/kredis/type/datetime.rb

@@ -4,11 +4,11 @@ module Kredis
   module Type
     class DateTime < ActiveModel::Type::DateTime
       def serialize(value)
-        super&.iso8601(9)
+        super&.utc&.iso8601(9)
       end
 
       def cast_value(value)
-        super&.to_datetime
+        super&.to_time
       end
     end
   end

data/lib/kredis/type_casting.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 require "json"
 require "active_model/type"
-require "kredis/type/json"
+require "kredis/type/boolean"
 require "kredis/type/datetime"
+require "kredis/type/json"
 
 module Kredis::TypeCasting
   class InvalidType < StandardError; end
@@ -11,7 +14,7 @@ module Kredis::TypeCasting
     integer: ActiveModel::Type::Integer.new,
     decimal: ActiveModel::Type::Decimal.new,
     float: ActiveModel::Type::Float.new,
-    boolean: ActiveModel::Type::Boolean.new,
+    boolean: Kredis::Type::Boolean.new,
     datetime: Kredis::Type::DateTime.new,
     json: Kredis::Type::Json.new
   }

data/lib/kredis/types/callbacks_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Kredis::Types::CallbacksProxy
   attr_reader :type
   delegate :to_s, to: :type

data/lib/kredis/types/counter.rb

@@ -1,18 +1,22 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Counter < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :multi, :set, :incrby, :decrby, :get, :del, :exists?
 
   attr_accessor :expires_in
 
   def increment(by: 1)
     multi do
-      set 0, ex: expires_in, nx: true
+      set 0, ex: expires_in, nx: true if expires_in
       incrby by
     end[-1]
   end
 
   def decrement(by: 1)
     multi do
-      set 0, ex: expires_in, nx: true
+      set 0, ex: expires_in, nx: true if expires_in
       decrby by
     end[-1]
   end
@@ -24,4 +28,9 @@ class Kredis::Types::Counter < Kredis::Types::Proxying
   def reset
     del
   end
+
+  private
+    def set_default
+      increment by: default
+    end
 end

data/lib/kredis/types/cycle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Cycle < Kredis::Types::Counter
   attr_accessor :values
 

data/lib/kredis/types/enum.rb

@@ -1,9 +1,15 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/object/inclusion"
 
 class Kredis::Types::Enum < Kredis::Types::Proxying
-  proxying :set, :get, :del, :exists?
+  prepend Kredis::DefaultValues
+
+  InvalidDefault = Class.new(StandardError)
 
-  attr_accessor :values, :default
+  proxying :set, :get, :del, :exists?, :multi
+
+  attr_accessor :values
 
   def initialize(...)
     super
@@ -17,11 +23,14 @@ class Kredis::Types::Enum < Kredis::Types::Proxying
   end
 
   def value
-    get || default
+    get
   end
 
   def reset
-    del
+    multi do
+      del
+      set_default
+    end
   end
 
   private
@@ -31,4 +40,12 @@ class Kredis::Types::Enum < Kredis::Types::Proxying
         define_singleton_method("#{defined_value}!") { self.value = defined_value }
       end
     end
+
+    def set_default
+      if default.in?(values) || default.nil?
+        set default
+      else
+        raise InvalidDefault, "Default value #{default.inspect} for #{key} is not a valid option (Valid values: #{values.join(", ")})"
+      end
+    end
 end

data/lib/kredis/types/flag.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Flag < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :set, :exists?, :del
 
   attr_accessor :expires_in
@@ -14,4 +18,9 @@ class Kredis::Types::Flag < Kredis::Types::Proxying
   def remove
     del
   end
+
+  private
+    def set_default
+      mark if default
+    end
 end

data/lib/kredis/types/hash.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/hash"
 
 class Kredis::Types::Hash < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :hget, :hset, :hmget, :hdel, :hgetall, :hkeys, :hvals, :del, :exists?
 
   attr_accessor :typed
@@ -14,7 +18,7 @@ class Kredis::Types::Hash < Kredis::Types::Proxying
   end
 
   def update(**entries)
-    hset entries.transform_values{ |val| type_to_string(val, typed) } if entries.flatten.any?
+    hset entries.transform_values { |val| type_to_string(val, typed) }.compact if entries.flatten.any?
   end
 
   def values_at(*keys)
@@ -42,4 +46,9 @@ class Kredis::Types::Hash < Kredis::Types::Proxying
   def values
     strings_to_types(hvals || [], typed)
   end
+
+  private
+    def set_default
+      update(**default)
+    end
 end

data/lib/kredis/types/limiter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# A limiter is a specialized form of a counter that can be checked whether it has been exceeded and is provided fail safe. This means it can be used to guard login screens from brute force attacks without denying access in case Redis is offline.
+#
+# It will usually be used as an expiring limiter. Note that the limiter expires in total after the `expires_in` time used upon the first poke.
+#
+# It offers no guarentee that you can't poke yourself above the limit. You're responsible for checking `#exceeded?` yourself first, and this may produce a race condition. So only use this when the exact number of pokes is not critical.
+class Kredis::Types::Limiter < Kredis::Types::Counter
+  class LimitExceeded < StandardError; end
+
+  attr_accessor :limit
+
+  def poke
+    failsafe returning: true do
+      increment
+    end
+  end
+
+  def exceeded?
+    failsafe returning: false do
+      value >= limit
+    end
+  end
+end

data/lib/kredis/types/list.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Kredis::Types::List < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :lrange, :lrem, :lpush, :ltrim, :rpush, :exists?, :del
 
   attr_accessor :typed
@@ -24,4 +28,13 @@ class Kredis::Types::List < Kredis::Types::Proxying
   def clear
     del
   end
+
+  def last(n = nil)
+    n ? lrange(-n, -1) : lrange(-1, -1).first
+  end
+
+  private
+    def set_default
+      append default
+    end
 end

data/lib/kredis/types/ordered_set.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Kredis::Types::OrderedSet < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
+  proxying :multi, :zrange, :zrem, :zadd, :zremrangebyrank, :zcard, :exists?, :del, :zscore
+
+  attr_accessor :typed
+  attr_reader :limit
+
+  def elements
+    strings_to_types(zrange(0, -1) || [], typed)
+  end
+  alias to_a elements
+
+  def remove(*elements)
+    zrem(types_to_strings(elements, typed))
+  end
+
+  def include?(element)
+    !!zscore(type_to_string(element, typed))
+  end
+
+  def prepend(elements)
+    insert(elements, prepending: true)
+  end
+
+  def append(elements)
+    insert(elements)
+  end
+  alias << append
+
+  def limit=(limit)
+    raise "Limit must be greater than 0" if limit && limit <= 0
+
+    @limit = limit
+  end
+
+  private
+    def insert(elements, prepending: false)
+      elements = Array(elements)
+      return if elements.empty?
+
+      elements_with_scores = types_to_strings(elements, typed).map.with_index do |element, index|
+        incremental_score = index * 0.000001
+
+        score = if prepending
+          -base_score - incremental_score
+        else
+          base_score + incremental_score
+        end
+
+        [ score, element ]
+      end
+
+      multi do
+        zadd(elements_with_scores)
+        trim(from_beginning: prepending)
+      end
+    end
+
+    def base_score
+      process_start_time + process_uptime
+    end
+
+    def process_start_time
+      @process_start_time ||= unproxied_redis.time.join(".").to_f - process_uptime
+    end
+
+    def process_uptime
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+
+    def trim(from_beginning:)
+      return unless limit
+
+      if from_beginning
+        zremrangebyrank(limit, -1)
+      else
+        zremrangebyrank(0, -(limit + 1))
+      end
+    end
+
+    def set_default
+      append default
+    end
+end

data/lib/kredis/types/proxy/failsafe.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kredis::Types::Proxy::Failsafe
   def initialize(*)
     super

data/lib/kredis/types/proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Proxy
   require_relative "proxy/failsafe"
   include Failsafe
@@ -20,6 +22,16 @@ class Kredis::Types::Proxy
     end
   end
 
+  def watch(&block)
+    redis.watch(key) do
+      block.call
+    end
+  end
+
+  def unwatch
+    redis.unwatch
+  end
+
   def method_missing(method, *args, **kwargs)
     Kredis.instrument :proxy, **log_message(method, *args, **kwargs) do
       failsafe do

data/lib/kredis/types/proxying.rb

@@ -1,13 +1,16 @@
+# frozen_string_literal: true
+
 require "active_support/core_ext/module/delegation"
 
 class Kredis::Types::Proxying
   attr_accessor :proxy, :key
 
   def self.proxying(*commands)
-    delegate *commands, to: :proxy
+    delegate(*commands, to: :proxy)
   end
 
   def initialize(redis, key, **options)
+    @redis = redis
     @key = key
     @proxy = Kredis::Types::Proxy.new(redis, key)
     options.each { |key, value| send("#{key}=", value) }
@@ -17,6 +20,12 @@ class Kredis::Types::Proxying
     proxy.suppress_failsafe_with(returning: returning, &block)
   end
 
+  def unproxied_redis
+    # Generally, this should not be used. It's only here for the rare case where we need to
+    # call Redis commands that don't reference a key and don't want to be pipelined.
+    @redis
+  end
+
   private
     delegate :type_to_string, :string_to_type, :types_to_strings, :strings_to_types, to: :Kredis
 end

data/lib/kredis/types/scalar.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Scalar < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :set, :get, :exists?, :del, :expire, :expireat
 
-  attr_accessor :typed, :default, :expires_in
+  attr_accessor :typed, :expires_in
 
   def value=(value)
     set type_to_string(value, typed), ex: expires_in
@@ -36,4 +40,9 @@ class Kredis::Types::Scalar < Kredis::Types::Proxying
   def expire_at(datetime)
     expireat datetime.to_i
   end
+
+  private
+    def set_default
+      self.value = default
+    end
 end

data/lib/kredis/types/set.rb

@@ -1,8 +1,15 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Set < Kredis::Types::Proxying
-  proxying :smembers, :sadd, :srem, :multi, :del, :sismember, :scard, :spop, :exists?
+  prepend Kredis::DefaultValues
 
-  attr_accessor :typed
+  proxying :smembers, :sadd, :srem, :multi, :del, :sismember, :scard, :spop, :exists?, :srandmember, :smove
 
+  attr_accessor :typed
+  def move(set, member)
+    destination = set.respond_to?(:key) ? set.key : set
+    smove(destination, member)
+  end
   def members
     strings_to_types(smembers || [], typed).sort
   end
@@ -33,10 +40,23 @@ class Kredis::Types::Set < Kredis::Types::Proxying
   end
 
   def take
-    spop
+    string_to_type(spop, typed)
   end
 
   def clear
     del
   end
+
+  def sample(count = nil)
+    if count.nil?
+      string_to_type(srandmember(count), typed)
+    else
+      strings_to_types(srandmember(count), typed)
+    end
+  end
+
+  private
+    def set_default
+      add default
+    end
 end

data/lib/kredis/types/slots.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Slots < Kredis::Types::Proxying
   class NotAvailable < StandardError; end
 

data/lib/kredis/types/unique_list.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # You'd normally call this a set, but Redis already has another data type for that
 class Kredis::Types::UniqueList < Kredis::Types::List
   proxying :multi, :ltrim, :exists?
@@ -22,7 +24,7 @@ class Kredis::Types::UniqueList < Kredis::Types::List
     multi do
       remove elements
       super
-      ltrim -limit, -1 if limit
+      ltrim(-limit, -1) if limit
     end
   end
   alias << append

data/lib/kredis/types.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kredis::Types
   autoload :CallbacksProxy, "kredis/types/callbacks_proxy"
 
@@ -39,36 +41,40 @@ module Kredis::Types
   end
 
 
-  def counter(key, expires_in: nil, config: :shared, after_change: nil)
-    type_from(Counter, config, key, after_change: after_change, expires_in: expires_in)
+  def counter(key, expires_in: nil, default: nil, config: :shared, after_change: nil)
+    type_from(Counter, config, key, after_change: after_change, default: default, expires_in: expires_in)
   end
 
   def cycle(key, values:, expires_in: nil, config: :shared, after_change: nil)
     type_from(Cycle, config, key, after_change: after_change, values: values, expires_in: expires_in)
   end
 
-  def flag(key, config: :shared, after_change: nil, expires_in: nil)
-    type_from(Flag, config, key, after_change: after_change, expires_in: expires_in)
+  def flag(key, default: nil, config: :shared, after_change: nil, expires_in: nil)
+    type_from(Flag, config, key, after_change: after_change, default: default, expires_in: expires_in)
   end
 
   def enum(key, values:, default:, config: :shared, after_change: nil)
     type_from(Enum, config, key, after_change: after_change, values: values, default: default)
   end
 
-  def hash(key, typed: :string, config: :shared, after_change: nil)
-    type_from(Hash, config, key, after_change: after_change, typed: typed)
+  def hash(key, typed: :string, default: nil, config: :shared, after_change: nil)
+    type_from(Hash, config, key, after_change: after_change, default: default, typed: typed)
+  end
+
+  def list(key, default: nil, typed: :string, config: :shared, after_change: nil)
+    type_from(List, config, key, after_change: after_change, default: default, typed: typed)
   end
 
-  def list(key, typed: :string, config: :shared, after_change: nil)
-    type_from(List, config, key, after_change: after_change, typed: typed)
+  def unique_list(key, default: nil, typed: :string, limit: nil, config: :shared, after_change: nil)
+    type_from(UniqueList, config, key, after_change: after_change, default: default, typed: typed, limit: limit)
   end
 
-  def unique_list(key, typed: :string, limit: nil, config: :shared, after_change: nil)
-    type_from(UniqueList, config, key, after_change: after_change, typed: typed, limit: limit)
+  def set(key, default: nil, typed: :string, config: :shared, after_change: nil)
+    type_from(Set, config, key, after_change: after_change, default: default, typed: typed)
   end
 
-  def set(key, typed: :string, config: :shared, after_change: nil)
-    type_from(Set, config, key, after_change: after_change, typed: typed)
+  def ordered_set(key, default: nil, typed: :string, limit: nil, config: :shared, after_change: nil)
+    type_from(OrderedSet, config, key, after_change: after_change, default: default, typed: typed, limit: limit)
   end
 
   def slot(key, config: :shared, after_change: nil)
@@ -79,6 +85,10 @@ module Kredis::Types
     type_from(Slots, config, key, after_change: after_change, available: available)
   end
 
+  def limiter(key, limit:, expires_in: nil, config: :shared, after_change: nil)
+    type_from(Limiter, config, key, after_change: after_change, expires_in: expires_in, limit: limit)
+  end
+
   private
     def type_from(type_klass, config, key, after_change: nil, **options)
       type_klass.new(configured_for(config), namespaced_key(key), **options).then do |type|
@@ -99,4 +109,6 @@ require "kredis/types/hash"
 require "kredis/types/list"
 require "kredis/types/unique_list"
 require "kredis/types/set"
+require "kredis/types/ordered_set"
 require "kredis/types/slots"
+require "kredis/types/limiter"

data/lib/kredis/version.rb

@@ -1,3 +1,3 @@
 module Kredis
-  VERSION = "1.3.0.1"
+  VERSION = "1.8.0"
 end

data/lib/kredis.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/module/attribute_accessors_per_thread"
@@ -8,6 +10,7 @@ require "kredis/connections"
 require "kredis/log_subscriber"
 require "kredis/namespace"
 require "kredis/type_casting"
+require "kredis/default_values"
 require "kredis/types"
 require "kredis/attributes"
 

data/lib/tasks/kredis/install.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :kredis do
   desc "Install kredis"
   task :install do

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 1.3.0.1
+  version: 1.8.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
 - David Heinemeier Hansson
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-13 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -25,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: redis
   requirement: !ruby/object:Gem::Requirement
@@ -59,7 +72,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.0
-description:
 email: david@hey.com
 executables: []
 extensions: []
@@ -72,10 +84,12 @@ files:
 - lib/kredis.rb
 - lib/kredis/attributes.rb
 - lib/kredis/connections.rb
+- lib/kredis/default_values.rb
 - lib/kredis/log_subscriber.rb
 - lib/kredis/migration.rb
 - lib/kredis/namespace.rb
 - lib/kredis/railtie.rb
+- lib/kredis/type/boolean.rb
 - lib/kredis/type/datetime.rb
 - lib/kredis/type/json.rb
 - lib/kredis/type_casting.rb
@@ -86,7 +100,9 @@ files:
 - lib/kredis/types/enum.rb
 - lib/kredis/types/flag.rb
 - lib/kredis/types/hash.rb
+- lib/kredis/types/limiter.rb
 - lib/kredis/types/list.rb
+- lib/kredis/types/ordered_set.rb
 - lib/kredis/types/proxy.rb
 - lib/kredis/types/proxy/failsafe.rb
 - lib/kredis/types/proxying.rb
@@ -100,7 +116,6 @@ homepage: https://github.com/rails/kredis
 licenses:
 - MIT
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -115,8 +130,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.2
-signing_key:
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Higher-level data structures built on Redis.
 test_files: []