kredis 1.4.0 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdd8725b73c1bac9541b7b48ee62ebb46a8c51eaf78abe367fda75a12ee8c425
-  data.tar.gz: fcee76b43f62b3bd0a99fe7d258cb1b5edab0a8d7f408f15f7e11be01a40b219
+  metadata.gz: 15ed6996059d28937ffa4f43a35e53d1e8fbc1894a30446575d9c00c390cd838
+  data.tar.gz: 296f80ea7719d69334d50240c9fce5969df4f8d976800013167c1fb0ebe6a0b3
 SHA512:
-  metadata.gz: 1bd30168c4efb0e23f65f15eb0e0b34c0b3a62a6c871da6be82192187482f0fddc55405ffb52c12f8dad4397246b55f7d292aa3bbbd8d3dc75a4fdd2e94e009e
-  data.tar.gz: 7dc32845d42347bcabe655447174d9cfb8b5e1d738fdf59af96557a455dc55ca52fced20fd76e514a21628dd725312120cbb6f0577e7925d6a6da585e77ffbf8
+  metadata.gz: cae34ebe3f21fe7c0e9cc0da5fc14bdc0d15931436bf7f07c552c14090489806990779ffd219be054f050468c809e23bf79302365f59f2dfced4b6a054ad352c
+  data.tar.gz: 96513897d1badc12f4fc6b2e51e017958f7e5eeaa5730d06bcb9d9a12d71ae09a4eb8ce2661e70a70647f4c4d7e5543a30451ab64d290b91de20d47602f30398

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"
@@ -49,10 +49,10 @@ list = Kredis.list "mylist"
 list << "hello world!"               # => RPUSH mylist "hello world!"
 [ "hello world!" ] == list.elements  # => LRANGE mylist 0, -1
 
-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
 
 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"
@@ -62,6 +62,14 @@ unique_list << "5"                             # => LREM myuniquelist 0, "5" + R
 unique_list.remove(3)                          # => LREM myuniquelist 0, "3"
 [ "4", "2", "1", "5" ] == unique_list.elements # => LRANGE myuniquelist 0, -1
 
+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"
@@ -155,15 +163,7 @@ 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
-```
+### Models
 
 You can use all these structures in models:
 
@@ -189,6 +189,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 +224,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`
@@ -220,14 +255,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 +286,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,16 @@ 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_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 +90,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 +109,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 +122,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,3 +1,5 @@
+# frozen_string_literal: true
+
 require "redis"
 
 module Kredis::Connections
@@ -6,10 +8,8 @@ module Kredis::Connections
   mattr_accessor :connector, default: ->(config) { Redis.new(config) }
 
   def configured_for(name)
-    connections[name] ||= begin
-      Kredis.instrument :meta, message: "Connected to #{name}" do
-        connector.call configurator.config_for("redis/#{name}")
-      end
+    connections[name] ||= Kredis.instrument :meta, message: "Connected to #{name}" do
+      connector.call configurator.config_for("redis/#{name}")
     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

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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Kredis::Namespace
   def namespace=(namespace)
     Thread.current[:kredis_namespace] = namespace

data/lib/kredis/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Kredis::Railtie < ::Rails::Railtie
   config.kredis = ActiveSupport::OrderedOptions.new
 

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_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) } 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/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
@@ -28,4 +32,9 @@ class Kredis::Types::List < Kredis::Types::Proxying
   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,4 +1,8 @@
+# frozen_string_literal: true
+
 class Kredis::Types::Set < Kredis::Types::Proxying
+  prepend Kredis::DefaultValues
+
   proxying :smembers, :sadd, :srem, :multi, :del, :sismember, :scard, :spop, :exists?, :srandmember
 
   attr_accessor :typed
@@ -47,4 +51,9 @@ class Kredis::Types::Set < Kredis::Types::Proxying
       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)
@@ -99,4 +105,5 @@ 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"

data/lib/kredis/version.rb

@@ -1,3 +1,3 @@
 module Kredis
-  VERSION = "1.4.0"
+  VERSION = "1.6.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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.6.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-06-18 00:00:00.000000000 Z
+date: 2023-10-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,10 +86,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
@@ -101,6 +103,7 @@ files:
 - lib/kredis/types/flag.rb
 - lib/kredis/types/hash.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
@@ -129,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Higher-level data structures built on Redis.