kredis 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57c373219f474818bb85a7da4ef3a07bd4910cd685704b54549969c364ee5993
-  data.tar.gz: f220ce448caa279514e249bc7c2f744c7276946d5f5af5a9899a9f6e14d3b5be
+  metadata.gz: 9aa90994f3d30a19d52df3fbc284d43d2637e940de06f221ecffc2853eeda459
+  data.tar.gz: 713137c0ec2c28bfb80df9c94b3e61c4b8f5906c9d68631fd5e26e4ac8ef0771
 SHA512:
-  metadata.gz: ef637b80601d21e815317201ab426da35a56926a2d069303cf1244e5a51f4ab0f80f7ef6e47a566d306248bbc2006c8a0dcdfd6990e0abf3057b5474ba7b6fc0
-  data.tar.gz: 99e4587242b125cfc78deff59e410055f9fefbfce726942ce1192e6065a6e08c1cfd0d83d409221c54418803b4405643ce8f873de8fbb0ef0c781ba882625c0e
+  metadata.gz: afcbb020c7e7c412090a7798c433882adf7d54e293728eff3a7d39b655d41531a3bae5f307ea10faa72a39e6ed1cb1f7db1f3f6535351299d26f65fd20e728fb
+  data.tar.gz: 7de324aa868056600c28d82911ef654c7d9f58c5d85823ab1271a7518c76f9dbb31a2be23082cb9ab2bf210401eac0ceca698412a38f01779af310bcf5893624

data/README.md

@@ -1,11 +1,94 @@
 # 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.string "myinteger"
+integer.value = 5  # => SET myinteger "5"
+5 == string.value # => GET myinteger
+
+json = Kredis.json "myjson"
+integer.value = { "one" => 1, "two" => "2" }  # => SET myjson "{\"one\":1,\"two\":\"2\"}"
+{ "one" => 1, "two" => "2" } == string.value  # => GET myjson
+```
+
+There are data structures for counters, enums, flags, lists, uniqe lists, sets, and slots:
+
+```ruby
+list = Kredis.list "mylist", typed: :integer
+list.append([ 1, 2, 3 ])        # => LPUSH mylist "1" "2" "3"
+list << 4                       # => LPUSH mylist "4"
+[ 1, 2, 3, 4 ] == list.elements # LRANGE 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.elements # => SMEMBERS myset
+
+counter = Kredis.counter "mycounter", expires_in: 15.minutes
+counter.increment by: 2         # => SETEX "mycounter" 900 0 + INCR "mycounter" 2
+2 == counter.value              # => GET "mycounter"
+travel 16.minutes
+0 == counter.value              # => GET "mycounter"
+```
+
+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.
 
-...
 
 ## License
 

data/lib/kredis.rb

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

data/lib/kredis/attributes.rb

@@ -3,80 +3,70 @@ module Kredis::Attributes
 
   class_methods do
     def kredis_proxy(name, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_proxy"
+      kredis_connection_with __method__, name, key, 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.proxy(kredis_key_evaluated(key) || kredis_key_for_attribute(name), config: config))
-        end
-      end
+    def kredis_string(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
     end
 
-    def kredis_list(name, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_list"
+    def kredis_integer(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, 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.list(kredis_key_evaluated(key) || kredis_key_for_attribute(name), config: config))
-        end
-      end
+    def kredis_datetime(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
     end
 
-    def kredis_unique_list(name, limit: nil, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_unique_list"
+    def kredis_flag(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
 
-      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_evaluated(key) || kredis_key_for_attribute(name), limit: limit, config: config))
-        end
+      define_method("#{name}?") do
+        send(name).marked?
       end
     end
 
-    def kredis_flag(name, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_flag"
+    def kredis_enum(name, key: nil, values:, default:, config: :shared)
+      kredis_connection_with __method__, name, key, values: values, default: default, 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.flag(kredis_key_evaluated(key) || kredis_key_for_attribute(name), config: config))
-        end
-      end
+    def kredis_json(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, config: config
+    end
 
-      define_method("#{name}?") do
-        instance_variable_defined?(ivar_symbol) && instance_variable_get(ivar_symbol).marked?
-      end
+    def kredis_list(name, key: nil, typed: :string, config: :shared)
+      kredis_connection_with __method__, name, key, typed: typed, config: config
     end
 
-    def kredis_string(name, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_string"
+    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
 
-      define_method(name) do
-        if instance_variable_defined?(ivar_symbol)
-          instance_variable_get(ivar_symbol)
-        else
-          instance_variable_set(ivar_symbol, Kredis.string(kredis_key_evaluated(key) || kredis_key_for_attribute(name), config: config))
-        end
-      end
+    def kredis_set(name, key: nil, typed: :string, config: :shared)
+      kredis_connection_with __method__, name, key, typed: typed, config: config
     end
 
-    def kredis_integer(name, key: nil, config: :shared)
-      ivar_symbol = :"@#{name}_kredis_integer"
+    def kredis_slot(name, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, 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.integer(kredis_key_evaluated(key) || kredis_key_for_attribute(name), config: config))
+    def kredis_slots(name, available:, key: nil, config: :shared)
+      kredis_connection_with __method__, name, key, available: available, config: config
+    end
+
+    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
@@ -87,7 +77,7 @@ module Kredis::Attributes
       end
     end
 
-    def kredis_key_for_attribute(name, key: nil)
+    def kredis_key_for_attribute(name)
       "#{self.class.name.tableize.gsub("/", ":")}:#{id}:#{name}"
     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,47 @@
+require "active_support/core_ext/module/delegation"
+
+class Kredis::Migration
+  singleton_class.delegate :migrate_all, :migrate, 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)
+    find_keys_in_batches_matching(key_pattern) do |keys|
+      @redis.multi do
+        keys.each do |key|
+          ids = key.scan(/\d+/).map(&:to_i)
+          migrate from: key, to: yield(key, *ids)
+        end
+      end
+    end
+  end
+
+  def migrate(from:, to:)
+    to = Kredis.namespaced_key(to)
+
+    if from != to
+      log_migration "Migrating key #{from} to #{to}"
+      @redis.evalsha @copy_sha, keys: [ from, to ]
+    else
+      log_migration "Skipping unaltered migration key #{from}"
+    end
+  end
+
+  private
+    SCAN_BATCH_SIZE = 1_000
+
+    def find_keys_in_batches_matching(key_pattern, &block)
+      cursor = "0"
+      begin
+        cursor, keys = @redis.scan(cursor, match: key_pattern, count: SCAN_BATCH_SIZE)
+        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,7 +3,6 @@ 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
@@ -13,7 +12,7 @@ module Kredis
     end
 
     initializer "kredis.logger" do
-      Kredis.logger = Rails.logger
+      Kredis.logger = config.kredis.logger || Rails.logger
     end
 
     initializer "kredis.configurator" do
@@ -21,12 +20,13 @@ module Kredis
     end
 
     initializer "kredis.attributes" do
+      # TODO: Add run_load_hooks to ActiveModel::Model so this runs.
       ActiveSupport.on_load(:active_model) do
-        ActiveModel::Base.send :include, Kredis::Attributes
+        include Kredis::Attributes
       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.to_f
+    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.at(value.to_i)
+    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,16 +1,42 @@
 module Kredis::Types
   def proxy(key, config: :shared)
-    Kredis::Types::Proxy.new configured_for(config), namespaced_key(key)
+    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 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 unique_list(key, limit: nil, config: :shared)
-    UniqueList.new configured_for(config), namespaced_key(key), limit: limit
+  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
@@ -19,24 +45,39 @@ module Kredis::Types
     Flag.new configured_for(config), namespaced_key(key)
   end
 
-  def string(key, config: :shared)
-    Kredis::Types::String.new configured_for(config), namespaced_key(key)
+  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 integer(key, config: :shared)
-    Kredis::Types::Integer.new configured_for(config), namespaced_key(key)
+  def slot(key, config: :shared)
+    Slots.new configured_for(config), namespaced_key(key), available: 1
   end
 
-  def mutex(key, expires_in: nil, config: :shared)
-    Mutex.new configured_for(config), namespaced_key(key), expires_in: expires_in
+  def slots(key, available:, config: :shared)
+    Slots.new configured_for(config), namespaced_key(key), available: available
   end
 end
 
 require "kredis/types/proxy"
-require "kredis/types/list"
-require "kredis/types/unique_list"
+require "kredis/types/proxying"
+
+require "kredis/types/scalar"
 require "kredis/types/counter"
 require "kredis/types/flag"
-require "kredis/types/string"
-require "kredis/types/integer"
-require "kredis/types/mutex"
+require "kredis/types/enum"
+require "kredis/types/list"
+require "kredis/types/unique_list"
+require "kredis/types/set"
+require "kredis/types/slots"

data/lib/kredis/types/counter.rb

@@ -1,12 +1,11 @@
-class Kredis::Types::Counter < Kredis::Types::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, :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

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

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

data/lib/kredis/types/list.rb

@@ -1,17 +1,23 @@
-class Kredis::Types::List < Kredis::Types::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 if Array(elements).any?
+  def prepend(*elements)
+    lpush types_to_strings(elements) if elements.flatten.any?
   end
 
-  def append(elements)
-    rpush elements if Array(elements).any?
+  def append(*elements)
+    rpush types_to_strings(elements) if elements.flatten.any?
   end
+  alias << append
 end

data/lib/kredis/types/proxy.rb

@@ -1,14 +1,26 @@
 class Kredis::Types::Proxy
-  def initialize(redis, key)
+  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(...)
+    redis.multi(...)
   end
 
   def method_missing(method, *args, **kwargs)
-    Kredis.logger&.debug "[Kredis] #{method} #{@key} #{args.inspect if args.compact_blank.any?} #{kwargs.inspect if kwargs.compact_blank.any?}".chomp
-    @redis.public_send method, @key, *args, **kwargs
+    Kredis.logger&.debug log_message(method, *args, **kwargs)
+    redis.public_send method, key, *args, **kwargs
   end
+
+  private
+    def log_message(method, *args, **kwargs)
+      args      = args.flatten.compact_blank.presence
+      kwargs    = kwargs.compact_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/proxying.rb

@@ -0,0 +1,18 @@
+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
+
+  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
+  end
+
+  def take
+    spop
+  end
+
+  def clear
+    del
+  end
+end

data/lib/kredis/types/slots.rb

@@ -0,0 +1,41 @@
+class Kredis::Types::Slots < Kredis::Types::Proxying
+  class NotAvailable < StandardError; end
+
+  proxying :incr, :decr, :get, :del
+
+  attr_accessor :available
+
+  def reserve
+    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
+
+  def release
+    decr
+  end
+
+  def available?
+    get.to_i < available
+  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 if Array(elements).any?
+      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 if Array(elements).any?
+      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.2"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kredis
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Kasper Timm Hansen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-01-30 00:00:00.000000000 Z
+date: 2021-02-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -50,17 +50,20 @@ files:
 - lib/kredis.rb
 - lib/kredis/attributes.rb
 - lib/kredis/connections.rb
-- lib/kredis/logger.rb
+- lib/kredis/migration.rb
 - lib/kredis/namespace.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/integer.rb
 - lib/kredis/types/list.rb
-- lib/kredis/types/mutex.rb
 - lib/kredis/types/proxy.rb
-- lib/kredis/types/string.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

data/lib/kredis/logger.rb

@@ -1,5 +0,0 @@
-require "redis"
-
-module Kredis::Logger
-  mattr_accessor :logger
-end

data/lib/kredis/types/integer.rb

@@ -1,9 +0,0 @@
-class Kredis::Types::Integer < Kredis::Types::String
-  def value
-    get&.to_i
-  end
-
-  def to_s
-    value.to_s
-  end
-end

data/lib/kredis/types/mutex.rb

@@ -1,25 +0,0 @@
-class Kredis::Types::Mutex < Kredis::Types::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

data/lib/kredis/types/string.rb

@@ -1,21 +0,0 @@
-class Kredis::Types::String < Kredis::Types::Proxy
-  def assign=(value)
-    set value
-  end
-
-  def assigned?
-    exists?
-  end
-
-  def value
-    get
-  end
-
-  def to_s
-    value
-  end
-
-  def clear
-    del
-  end
-end