kredis 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6a806a43280483f33a61cb2133b869d7742251eb7df3ccfcfe18c4bc5274873
-  data.tar.gz: 1c255fa02c7172090724ee01b5f72ec5540b4e38c43505135bd123c2ab6a1c79
+  metadata.gz: f3e3619ec3a977b472348572202b324c813d550d43cc866ec1aab7dad8e463f0
+  data.tar.gz: 920c49f0cfe443a71dd5dc8f112070ab8061bbe2d352c98b45026ceeed871f2e
 SHA512:
-  metadata.gz: 270f4fda9ed70fb489e9b54431ae01118f2f25fcb6632a8eb83abb50e4ff0871729a4282989c75801bd6f0c7520f72d51923b6980c46089f0f27a3d8145a2a6e
-  data.tar.gz: d1d5cc05fbe9091db57a20ad138e08cf1ee60d00765ebf69222cf53f9c153ce0a260496d0dd406c807ef1b6b51164ab365487c72e9299ca703d776add411c564
+  metadata.gz: 8f97bda6b251a100411c0338d2760aa1c2565f3ee1901f5f4971123cbe8b7a49fabf64ccc210775e9694263fd1a2a142641bcf81659776f746d05163640afda5
+  data.tar.gz: 546b9246e3952a92452fe55cf574233b12d50f29bdeb345c7efe3ebf86bd3ab9a6ff4d22731438ae3258586caca530c1e7229ffee9b581a4a22b04f585dd4467

data/README.md

@@ -1,11 +1,161 @@
 # Kredis
 
-Keyed Redis encapsulates higher-level data structures around a single key, so you can interact with them as coherent objects rather than isolated procedural commands.
+Kredis (Keyed Redis) encapsulates higher-level types and data structures around a single key, so you can interact with them as coherent objects rather than isolated procedural commands. These higher-level structures can be configured as attributes within Active Models and Active Records using a declarative DSL.
 
+Kredis is configured using env-aware YAML files, using `Rails.application.config_for`, so you can locate the data structures on separate Redis instances, if you've reached a scale where a single shared instance is no longer sufficient.
 
-## Development
+Kredis provides namespacing support for keys such that you can safely run parallel testing against the data structures without different tests trampling each others data.
+
+
+## Examples
+
+Kredis provides typed scalars for strings, integers, decimals, floats, booleans, datetimes, and JSON hashes:
+
+```ruby
+string = Kredis.string "mystring"
+string.value = "hello world!"  # => SET mystring "hello world"
+"hello world!" == string.value # => GET mystring
+
+integer = Kredis.integer "myinteger"
+integer.value = 5  # => SET myinteger "5"
+5 == integer.value # => GET myinteger
+
+json = Kredis.json "myjson"
+json.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
+{ "one" => 1, "two" => "2" } == json.value  # => GET myjson
+```
+
+There are data structures for counters, enums, flags, lists, unique lists, sets, and slots:
+
+```ruby
+list = Kredis.list "mylist"
+list << "hello world!"
+[ "hello world!" ] == list.elements
+
+integer_list = Kredis.list "myintegerlist", typed: :integer
+integer_list.append([ 1, 2, 3 ])        # => LPUSH myintegerlist "1" "2" "3"
+integer_list << 4                       # => LPUSH myintegerlist "4"
+[ 1, 2, 3, 4 ] == integer_list.elements # LRANGE 0 -1
+
+unique_list = Kredis.unique_list "myuniquelist"
+unique_list.append(%w[ 2 3 4 ])
+unique_list.prepend(%w[ 1 2 3 4 ])
+unique_list.append([])
+unique_list << "5"
+unique_list.remove(3)
+[ "1", "2", "4", "5" ] == unique_list.elements
+
+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.elements # => SMEMBERS myset
+
+head_count = Kredis.counter "headcount"
+0 == head_count.value              # => GET "headcount"
+head_count.increment
+head_count.increment
+head_count.decrement
+1 == head_count.value              # => GET "headcount"
+
+counter = Kredis.counter "mycounter", expires_in: 5.seconds
+counter.increment by: 2         # => SETEX "mycounter" 900 0 + INCR "mycounter" 2
+2 == counter.value              # => GET "mycounter"
+sleep 6.seconds
+0 == counter.value              # => GET "mycounter"
+
+enum = Kredis.enum "myenum", values: %w[ one two three ], default: "one"
+"one" == enum.value
+true == enum.one?
+enum.value = "two"
+"two" == enum.value
+enum.value = "four"
+"two" == enum.value
+enum.reset
+"one" == enum.value
+
+slots = Kredis.slots "myslots", available: 3
+true == slots.available?
+slots.reserve
+true == slots.available?
+slots.reserve
+true == slots.available?
+slots.reserve
+true == slots.available?
+slots.reserve
+false == slots.available?
+slots.release
+true == slots.available?
+slots.reset
+
+flag = Kredis.flag "myflag"
+false == flag.marked?
+flag.mark
+true == flag.marked?
+flag.remove
+false == flag.marked?
+
+flag.mark(expires_in: 1.second)
+true == flag.marked?
+sleep 0.5.seconds
+true == flag.marked?
+sleep 0.6.seconds
+false == flag.marked?
+```
+
+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
+```
+
+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_unique_list :skills, limit: 2
+  kredis_enum :morning, values: %w[ bright blue black ], default: "bright"
+end
+
+person = Person.find(5)
+person.names.append "David", "Heinemeier", "Hansson" # => SADD person:5:names "David" "Heinemeier" "Hansson"
+true == person.morning.bright?
+person.morning.value = "blue"
+true == person.morning.blue?
+```
+
+
+## Installation
+
+1. Add the `kredis` gem to your Gemfile: `gem 'kredis'`
+2. Run `./bin/bundle install`
+3. Add a default configuration under `config/redis/shared.yml`
+
+A default configuration can look like this for `config/redis/shared.yml`:
+
+```yaml
+production: &production
+  host: <%= ENV.fetch("REDIS_SHARED_HOST", "127.0.0.1") %>
+  port: <%= ENV.fetch("REDIS_SHARED_PORT", "6379") %>
+  timeout: 1
+
+development: &development
+  host: <%= ENV.fetch("REDIS_SHARED_HOST", "127.0.0.1") %>
+  port: <%= ENV.fetch("REDIS_SHARED_PORT", "6379") %>
+  timeout: 1
+
+test:
+  <<: *development
+```
+
+Additional configurations can be added under `config/redis/*.yml` and referenced when a type is created, e.g. `Kredis.string("mystring", config: :strings)` would lookup `config/redis/strings.yml`. Under the hood `Kredis.configured_for` is called which'll pass the configuration on to `Redis.new`.
 
-...
 
 ## License
 

data/lib/kredis.rb

@@ -1,14 +1,20 @@
 require "kredis/railtie"
+require "kredis/version"
 
 require "kredis/connections"
+require "kredis/namespace"
 require "kredis/types"
 require "kredis/attributes"
-require "kredis/namespace"
+require "kredis/type_casting"
 
 module Kredis
-  include Connections
-  include Namespace
-  include Types
+  include Connections, Namespace, Types, TypeCasting
 
   extend self
+
+  mattr_accessor :logger
+
+  def redis(config: :shared)
+    configured_for(config)
+  end
 end

data/lib/kredis/attributes.rb

@@ -2,33 +2,86 @@ module Kredis::Attributes
   extend ActiveSupport::Concern
 
   class_methods do
-    def kredis_list(name, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_list"
-
-      define_method(name) do
-        if instance_variable_defined?(ivar_symbol)
-          instance_variable_get(ivar_symbol)
-        else
-          instance_variable_set(ivar_symbol, Kredis.list(kredis_key_for_attribute(name), config: config))
-        end
+    def kredis_proxy(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_string(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_integer(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_datetime(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_flag(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+
+      define_method("#{name}?") do
+        send(name).marked?
       end
     end
 
-    def kredis_unique_list(name, limit: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_unique_list"
+    def kredis_enum(name, key: nil, values:, default:, config: :shared)
+      kredis_connection_with __method__, name, key, values: values, default: default, config: config
+    end
+
+    def kredis_json(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_list(name, key: nil, typed: :string, config: :shared)
+      kredis_connection_with __method__, name, key, typed: typed, config: config
+    end
+
+    def kredis_unique_list(name, limit: nil, key: nil, typed: :string, config: :shared)
+      kredis_connection_with __method__, name, key, limit: limit, typed: typed, config: config
+    end
+
+    def kredis_set(name, key: nil, typed: :string, config: :shared)
+      kredis_connection_with __method__, name, key, typed: typed, config: config
+    end
+
+    def kredis_slot(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
+
+    def kredis_slots(name, available:, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, available: available, config: config
+    end
 
-      define_method(name) do
-        if instance_variable_defined?(ivar_symbol)
-          instance_variable_get(ivar_symbol)
-        else
-          instance_variable_set(ivar_symbol, Kredis.unique_list(kredis_key_for_attribute(name), limit: limit, config: config))
+    private
+      def kredis_connection_with(method, name, key, **options)
+        ivar_symbol = :"@#{name}_#{method}"
+        type = method.to_s.sub("kredis_", "")
+
+        define_method(name) do
+          if instance_variable_defined?(ivar_symbol)
+            instance_variable_get(ivar_symbol)
+          else
+            instance_variable_set(ivar_symbol, Kredis.send(type, kredis_key_evaluated(key) || kredis_key_for_attribute(name), **options))
+          end
         end
       end
-    end
   end
 
   private
+    def kredis_key_evaluated(key)
+      case key
+      when String then key
+      when Proc   then key.call(self)
+      end
+    end
+
     def kredis_key_for_attribute(name)
-      "#{self.class.name.tableize.gsub("/", ":")}:#{id}:#{name}"
+      "#{self.class.name.tableize.gsub("/", ":")}:#{extract_kredis_id}:#{name}"
+    end
+
+    def extract_kredis_id
+      try(:id) or raise NotImplementedError, "kredis needs a unique id, either implement an id method or pass a custom key."
     end
 end

data/lib/kredis/connections.rb

@@ -5,10 +5,14 @@ module Kredis::Connections
   mattr_accessor :configurator
 
   def configured_for(name)
-    connections[name] ||= Redis.new configurator.config_for("redis/#{name}")
+    connections[name] ||= begin
+      logger&.info "[Kredis] Connected to #{name}"
+      Redis.new configurator.config_for("redis/#{name}")
+    end
   end
 
   def clear_all
+    logger&.info "[Kredis] Connections all cleared"
     connections.each_value(&:flushdb)
   end
 end

data/lib/kredis/migration.rb

@@ -0,0 +1,51 @@
+require "active_support/core_ext/module/delegation"
+
+class Kredis::Migration
+  singleton_class.delegate :migrate_all, :migrate, :delete_all, to: :new
+
+  def initialize(config = :shared)
+    @redis = Kredis.configured_for config
+    @copy_sha = @redis.script "load", "redis.call('SETNX', KEYS[2], redis.call('GET', KEYS[1])); return 1;"
+  end
+
+  def migrate_all(key_pattern)
+    each_key_batch_matching(key_pattern) do |keys|
+      keys.each do |key|
+        ids = key.scan(/\d+/).map(&:to_i)
+        migrate from: key, to: yield(key, *ids)
+      end
+    end
+  end
+
+  def migrate(from:, to:)
+    namespaced_to = Kredis.namespaced_key(to)
+
+    if to.present? && from != namespaced_to
+      log_migration "Migrating key #{from} to #{namespaced_to}"
+      @redis.evalsha @copy_sha, keys: [ from, namespaced_to ]
+    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|
+      @redis.del *keys
+    end
+  end
+
+  private
+    SCAN_BATCH_SIZE = 1_000
+
+    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 { yield keys }
+      end until cursor == "0"
+    end
+
+    def log_migration(message)
+      Kredis.logger&.debug "[Kredis Migration] #{message}"
+    end
+end

data/lib/kredis/railtie.rb

@@ -3,26 +3,30 @@ require "rails/railtie"
 module Kredis
   class Railtie < ::Rails::Railtie
     config.kredis = ActiveSupport::OrderedOptions.new
-    config.eager_load_namespaces << Kredis
 
     initializer "kredis.testing" do
       ActiveSupport.on_load(:active_support_test_case) do
-        parallelize_setup    { |worker| Kredis.namespace = "test-#{worker}" }
-        parallelize_teardown { Kredis.clear_all }
+        parallelize_setup { |worker| Kredis.namespace = "test-#{worker}" }
+        teardown { Kredis.clear_all }
       end
     end
 
+    initializer "kredis.logger" do
+      Kredis.logger = config.kredis.logger || Rails.logger
+    end
+
     initializer "kredis.configurator" do
       Kredis.configurator = Rails.application
     end
 
     initializer "kredis.attributes" do
-      ActiveSupport.on_load(:active_model) do
-        ActiveModel::Base.send :include, Kredis::Attributes
+      # No load hook for Active Model, just defer until after initialization.
+      config.after_initialize do
+        ActiveModel::Model.include Kredis::Attributes if defined?(ActiveModel::Model)
       end
 
       ActiveSupport.on_load(:active_record) do
-        ActiveRecord::Base.send :include, Kredis::Attributes
+        include Kredis::Attributes
       end
     end
   end

data/lib/kredis/type_casting.rb

@@ -0,0 +1,48 @@
+module Kredis::TypeCasting
+  class InvalidType < StandardError; end
+
+  VALID_TYPES = %i[ string integer decimal float boolean datetime json ]
+
+  def type_to_string(value)
+    case value
+    when nil
+      ""
+    when Integer
+      value.to_s
+    when BigDecimal
+      value.to_d
+    when Float
+      value.to_s
+    when TrueClass, FalseClass
+      value ? "t" : "f"
+    when Time, DateTime, ActiveSupport::TimeWithZone
+      value.iso8601(9)
+    when Hash
+      JSON.dump(value)
+    else
+      value
+    end
+  end
+
+  def string_to_type(value, type)
+    raise InvalidType if type && !type.in?(VALID_TYPES)
+
+    case type
+    when nil, :string then value
+    when :integer     then value.to_i
+    when :decimal     then value.to_d
+    when :float       then value.to_f
+    when :boolean     then value == "t" ? true : false
+    when :datetime    then Time.iso8601(value)
+    when :json        then JSON.load(value)
+    end if value.present?
+  end
+
+  def types_to_strings(values)
+    Array(values).flatten.map { |value| type_to_string(value) }
+  end
+
+  def strings_to_types(values, type)
+    Array(values).flatten.map { |value| string_to_type(value, type) }
+  end
+end

data/lib/kredis/types.rb

@@ -1,27 +1,83 @@
 module Kredis::Types
-  def keyed(key, config: :shared)
-    Kredis::Proxy.new configured_for(config), namespaced_key(key)
+  def proxy(key, config: :shared)
+    Proxy.new configured_for(config), namespaced_key(key)
   end
 
-  def list(key, config: :shared)
-    List.new configured_for(config), namespaced_key(key)
+
+  def scalar(key, typed: :string, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: typed, default: default
+  end
+
+  def string(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :string, default: default
+  end
+
+  def integer(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :integer, default: default
+  end
+
+  def decimal(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :decimal, default: default
   end
 
-  def unique_list(key, limit: nil, config: :shared)
-    UniqueList.new configured_for(config), namespaced_key(key), limit: limit
+  def float(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :float, default: default
   end
 
+  def boolean(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :boolean, default: default
+  end
+
+  def datetime(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :datetime, default: default
+  end
+
+  def json(key, default: nil, config: :shared)
+    Scalar.new configured_for(config), namespaced_key(key), typed: :json, default: default
+  end
+
+
   def counter(key, expires_in: nil, config: :shared)
     Counter.new configured_for(config), namespaced_key(key), expires_in: expires_in
   end
 
-  def mutex(key, expires_in: nil, config: :shared)
-    Mutex.new configured_for(config), namespaced_key(key), expires_in: expires_in
+  def flag(key, config: :shared)
+    Flag.new configured_for(config), namespaced_key(key)
+  end
+
+  def enum(key, values:, default:, config: :shared)
+    Enum.new configured_for(config), namespaced_key(key), values: values, default: default
+  end
+
+  def list(key, typed: :string, config: :shared)
+    List.new configured_for(config), namespaced_key(key), typed: typed
+  end
+
+  def unique_list(key, typed: :string, limit: nil, config: :shared)
+    UniqueList.new configured_for(config), namespaced_key(key), typed: typed, limit: limit
+  end
+
+  def set(key, typed: :string, config: :shared)
+    Set.new configured_for(config), namespaced_key(key), typed: typed
+  end
+
+  def slot(key, config: :shared)
+    Slots.new configured_for(config), namespaced_key(key), available: 1
+  end
+
+  def slots(key, available:, config: :shared)
+    Slots.new configured_for(config), namespaced_key(key), available: available
   end
 end
 
-require "kredis/proxy"
+require "kredis/types/proxy"
+require "kredis/types/proxying"
+
+require "kredis/types/scalar"
+require "kredis/types/counter"
+require "kredis/types/flag"
+require "kredis/types/enum"
 require "kredis/types/list"
 require "kredis/types/unique_list"
-require "kredis/types/counter"
-require "kredis/types/mutex"
+require "kredis/types/set"
+require "kredis/types/slots"

data/lib/kredis/types/counter.rb

@@ -1,16 +1,22 @@
-class Kredis::Types::Counter < Kredis::Proxy
-  def initialize(redis, key, expires_in: nil)
-    @expires_in = expires_in
-    super redis, key
-  end
+class Kredis::Types::Counter < Kredis::Types::Proxying
+  proxying :multi, :set, :incrby, :decrby, :get
+
+  attr_accessor :expires_in
 
   def increment(by: 1)
     multi do
-      set 0, ex: @expires_in, nx: true
+      set 0, ex: expires_in, nx: true
       incrby by
     end
   end
 
+  def decrement(by: 1)
+    multi do
+      set 0, ex: expires_in, nx: true
+      decrby by
+    end
+  end
+
   def value
     get.to_i
   end

data/lib/kredis/types/enum.rb

@@ -0,0 +1,31 @@
+class Kredis::Types::Enum < Kredis::Types::Proxying
+  proxying :set, :get, :del
+
+  attr_accessor :values, :default
+
+  def initialize(...)
+    super
+    define_predicates_for_values
+  end
+
+  def value=(value)
+    if validated_choice = value.presence_in(values)
+      set validated_choice
+    end
+  end
+
+  def value
+    get || default
+  end
+
+  def reset
+    del
+  end
+
+  private
+    def define_predicates_for_values
+      values.each do |defined_value|
+        define_singleton_method("#{defined_value}?") { value == defined_value }
+      end
+    end
+end

data/lib/kredis/types/flag.rb

@@ -0,0 +1,15 @@
+class Kredis::Types::Flag < Kredis::Types::Proxying
+  proxying :set, :exists?, :del
+
+  def mark(expires_in: nil)
+    set 1, ex: expires_in
+  end
+
+  def marked?
+    exists?
+  end
+
+  def remove
+    del
+  end
+end

data/lib/kredis/types/list.rb

@@ -1,17 +1,23 @@
-class Kredis::Types::List < Kredis::Proxy
+class Kredis::Types::List < Kredis::Types::Proxying
+  proxying :lrange, :lrem, :lpush, :rpush
+
+  attr_accessor :typed
+
   def elements
-    lrange(0, -1) || []
+    strings_to_types(lrange(0, -1) || [], typed)
   end
+  alias to_a elements
 
-  def remove(elements)
-    Array(elements).each { |element| lrem 0, element }
+  def remove(*elements)
+    types_to_strings(elements).each { |element| lrem 0, element }
   end
 
-  def prepend(elements)
-    lpush elements
+  def prepend(*elements)
+    lpush types_to_strings(elements) if elements.flatten.any?
   end
 
-  def append(elements)
-    rpush elements
+  def append(*elements)
+    rpush types_to_strings(elements) if elements.flatten.any?
   end
+  alias << append
 end

data/lib/kredis/types/proxy.rb

@@ -0,0 +1,31 @@
+class Kredis::Types::Proxy
+  require_relative "proxy/failsafe"
+  include Failsafe
+
+  attr_accessor :redis, :key
+
+  def initialize(redis, key, **options)
+    @redis, @key = redis, key
+    options.each { |key, value| send("#{key}=", value) }
+  end
+
+  def multi(...)
+    redis.multi(...)
+  end
+
+  def method_missing(method, *args, **kwargs)
+    failsafe do
+      Kredis.logger&.debug log_message(method, *args, **kwargs)
+      redis.public_send method, key, *args, **kwargs
+    end
+  end
+
+  private
+    def log_message(method, *args, **kwargs)
+      args      = args.flatten.reject(&:blank?).presence
+      kwargs    = kwargs.reject { |_k, v| v.blank? }.presence
+      type_name = self.class.name.split("::").last
+
+      "[Kredis #{type_name}] #{method.upcase} #{key} #{args&.inspect} #{kwargs&.inspect}".chomp
+    end
+end

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

@@ -0,0 +1,26 @@
+module Kredis::Types::Proxy::Failsafe
+  def initialize(*)
+    super
+    @fail_safe_suppressed = false
+  end
+
+  def failsafe
+    yield
+  rescue Redis::BaseError
+    raise if fail_safe_suppressed?
+  end
+
+  def suppress_failsafe_with(returning: nil)
+    old_fail_safe_suppressed, @fail_safe_suppressed = @fail_safe_suppressed, true
+    yield
+  rescue Redis::BaseError
+    returning
+  ensure
+    @fail_safe_suppressed = old_fail_safe_suppressed
+  end
+
+  private
+    def fail_safe_suppressed?
+      @fail_safe_suppressed
+    end
+end

data/lib/kredis/types/proxying.rb

@@ -0,0 +1,22 @@
+require "active_support/core_ext/module/delegation"
+
+class Kredis::Types::Proxying
+  attr_accessor :proxy, :redis, :key
+
+  def self.proxying(*commands)
+    delegate *commands, to: :proxy
+  end
+
+  def initialize(redis, key, **options)
+    @redis, @key = redis, key
+    @proxy = Kredis::Types::Proxy.new(redis, key)
+    options.each { |key, value| send("#{key}=", value) }
+  end
+
+  def failsafe(returning: nil, &block)
+    proxy.suppress_failsafe_with(returning: returning, &block)
+  end
+
+  private
+    delegate :type_to_string, :string_to_type, :types_to_strings, :strings_to_types, to: :Kredis
+end

data/lib/kredis/types/scalar.rb

@@ -0,0 +1,25 @@
+class Kredis::Types::Scalar < Kredis::Types::Proxying
+  proxying :set, :get, :exists?, :del
+
+  attr_accessor :typed, :default
+
+  def value=(value)
+    set type_to_string(value)
+  end
+
+  def value
+    string_to_type(get, typed) || default
+  end
+
+  def to_s
+    get || default&.to_s
+  end
+
+  def assigned?
+    exists?
+  end
+
+  def clear
+    del
+  end
+end

data/lib/kredis/types/set.rb

@@ -0,0 +1,42 @@
+class Kredis::Types::Set < Kredis::Types::Proxying
+  proxying :smembers, :sadd, :srem, :multi, :del, :sismember, :scard, :spop
+
+  attr_accessor :typed
+
+  def members
+    strings_to_types(smembers || [], typed).sort
+  end
+  alias to_a members
+
+  def add(*members)
+    sadd types_to_strings(members) if members.flatten.any?
+  end
+  alias << add
+
+  def remove(*members)
+    srem types_to_strings(members) if members.flatten.any?
+  end
+
+  def replace(*members)
+    multi do
+      del
+      add members
+    end
+  end
+
+  def include?(member)
+    sismember type_to_string(member)
+  end
+
+  def size
+    scard.to_i
+  end
+
+  def take
+    spop
+  end
+
+  def clear
+    del
+  end
+end

data/lib/kredis/types/slots.rb

@@ -0,0 +1,45 @@
+class Kredis::Types::Slots < Kredis::Types::Proxying
+  class NotAvailable < StandardError; end
+
+  proxying :incr, :decr, :get, :del
+
+  attr_accessor :available
+
+  def reserve
+    failsafe returning: false do
+      if block_given?
+        begin
+          if reserve
+            yield
+            true
+          else
+            false
+          end
+        ensure
+          release
+        end
+      else
+        if incr <= available
+          true
+        else
+          release
+          false
+        end
+      end
+    end
+  end
+
+  def release
+    decr
+  end
+
+  def available?
+    failsafe returning: false do
+      get.to_i < available
+    end
+  end
+
+  def reset
+    del
+  end
+end

data/lib/kredis/types/unique_list.rb

@@ -1,23 +1,23 @@
 # You'd normally call this a set, but Redis already has another data type for that
 class Kredis::Types::UniqueList < Kredis::Types::List
-  def initialize(redis, key, limit: nil)
-    @limit = limit
-    super redis, key
-  end
+  proxying :multi, :ltrim
+
+  attr_accessor :typed, :limit
 
   def prepend(elements)
     multi do
       remove elements
       super
-      ltrim 0, (@limit - 1) if @limit
-    end
+      ltrim 0, (limit - 1) if limit
+    end if Array(elements).flatten.any?
   end
 
   def append(elements)
     multi do
       remove elements
       super
-      ltrim (@limit - 1), -1 if @limit
-    end
+      ltrim (limit - 1), -1 if limit
+    end if Array(elements).flatten.any?
   end
+  alias << append
 end

data/lib/kredis/version.rb

@@ -1,3 +1,3 @@
 module Kredis
-  VERSION = "0.1.0"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - Kasper Timm Hansen
 - David Heinemeier Hansson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2021-02-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -31,15 +31,15 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '4.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.0'
-description: 
+        version: '4.2'
+description:
 email: david@hey.com
 executables: []
 extensions: []
@@ -50,20 +50,28 @@ files:
 - lib/kredis.rb
 - lib/kredis/attributes.rb
 - lib/kredis/connections.rb
+- lib/kredis/migration.rb
 - lib/kredis/namespace.rb
-- lib/kredis/proxy.rb
 - lib/kredis/railtie.rb
+- lib/kredis/type_casting.rb
 - lib/kredis/types.rb
 - lib/kredis/types/counter.rb
+- lib/kredis/types/enum.rb
+- lib/kredis/types/flag.rb
 - lib/kredis/types/list.rb
-- lib/kredis/types/mutex.rb
+- lib/kredis/types/proxy.rb
+- lib/kredis/types/proxy/failsafe.rb
+- lib/kredis/types/proxying.rb
+- lib/kredis/types/scalar.rb
+- lib/kredis/types/set.rb
+- lib/kredis/types/slots.rb
 - lib/kredis/types/unique_list.rb
 - lib/kredis/version.rb
 homepage: https://github.com/rails/kredis
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -71,7 +79,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -79,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Higher-level data structures built on Redis.
 test_files: []

data/lib/kredis/proxy.rb

@@ -1,13 +0,0 @@
-class Kredis::Proxy
-  def initialize(redis, key)
-    @redis, @key = redis, key
-  end
-
-  def multi(...)
-    @redis.multi(...)
-  end
-
-  def method_missing(method, *args, **kwargs)
-    @redis.public_send method, @key, *args, **kwargs
-  end
-end

data/lib/kredis/types/mutex.rb

@@ -1,25 +0,0 @@
-class Kredis::Types::Mutex < Kredis::Proxy
-  def initialize(redis, key, expires_in: nil)
-    @expires_in = expires_in
-    super redis, key
-  end
-
-  def lock
-    set 1, ex: @expires_in
-  end
-
-  def unlock
-    del
-  end
-
-  def locked?
-    get
-  end
-
-  def synchronize
-    lock
-    yield
-  ensure
-    unlock
-  end
-end