active_redis_db 1.0.0

data/lib/active_redis_db/key.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::Key < ActiveRedisDB::Base
+  class << self
+
+    def exists?(key)
+      client.exists(normalize_key(key))
+    end
+
+    def type?(key)
+      client.type(normalize_key(key))
+    end
+
+    def ttl?(key, format = :seconds)
+      normalized_key = normalize_key(key)
+
+      seconds?(format) ? client.ttl(normalized_key) : client.pttl(normalized_key)
+    end
+
+    def sort(key, opts = {})
+      client.sort(normalize_key(key), opts)
+    end
+
+    def sample
+      client.randomkey
+    end
+
+    def rename(key, value)
+      client.rename(normalize_key(key), value.to_s)
+    end
+
+    def rename!(key, value)
+      client.renamenx(normalize_key(key), value.to_s)
+    end
+
+    def destroy(key)
+      client.del(normalize_key(key))
+    end
+
+    def persist(key)
+      client.persist(normalize_key(key))
+    end
+
+    def expire(key, seconds, format = :seconds)
+      normalized_key = normalize_key(key)
+
+      if seconds?(format)
+        client.expire(normalized_key, seconds)
+      else
+        client.pexpire(normalized_key, seconds)
+      end
+    end
+
+    def expire_at(key, seconds, format = :seconds)
+      normalized_key = normalize_key(key)
+
+      if seconds?(format)
+        client.expireat(normalized_key, seconds)
+      else
+        client.pexpireat(normalized_key, seconds)
+      end
+    end
+
+    def dump(key)
+      client.dump(normalize_key(key))
+    end
+
+    def match(pattern = '*')
+      value = client.keys(normalize_key(pattern))
+      value = nil if value.empty?
+      value
+    end
+
+    def migrate(key, options)
+      client.migrate(normalize_key(key), options)
+    end
+
+    def move(key, destination)
+      client.move(normalize_key(key), destination)
+    end
+
+    def object(*args)
+      client.object(args)
+    end
+
+    def restore(key, milliseconds, value)
+      client.restore(normalize_key(key), milliseconds, value)
+    end
+
+    def scan(cursor, opts = {})
+      client.scan(cursor, opts)
+    end
+
+  end
+end

data/lib/active_redis_db/list.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::List < ActiveRedisDB::Base
+  class << self
+
+    def find(key, position = 1)
+      value = client.lindex(normalize_key(key), (position - 1))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first(key, limit = 1)
+      value = client.lrange(normalize_key(key), 0, -1)
+      value = (limit == 1 ? value.first : value.first(limit))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last(key, limit = 1)
+      value = client.lrange(normalize_key(key), 0, -1)
+      value = (limit == 1 ? value.last : value.last(limit))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def between(key, start = 1, finish = 0)
+      value = client.lrange(normalize_key(key), (start - 1), (finish - 1))
+      metatransform(value)
+    end
+
+    def all(key)
+      value = client.lrange(normalize_key(key), 0, -1)
+      metatransform(value)
+    end
+
+    def count(key)
+      client.llen(normalize_key(key))
+    end
+
+    def create(key, value, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
+    end
+
+    def create!(key, value, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
+    end
+
+    def create_limit(key, value, limit, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
+      client.ltrim(normalized_key, 0, (limit - 1))
+    end
+
+    def create_limit!(key, value, limit, order = :prepend)
+      normalized_key = normalize_key(key)
+
+      append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
+      client.ltrim(normalized_key, 0, (limit - 1))
+    end
+
+    def create_before(key, pivot, value)
+      client.linsert(normalize_key(key), :before, pivot, value)
+    end
+
+    def create_after(key, pivot, value)
+      client.linsert(normalize_key(key), :after, pivot, value)
+    end
+
+    def update(key, index, value)
+      client.lset(normalize_key(key), index, value)
+    end
+
+    def move(key, desination)
+      value = client.rpoplpush(normalize_key(key), normalize_key(desination))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def move_blocking(key, desination)
+      value = brpoplpush(normalize_key(key), normalize_key(desination))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def destroy(key, count, value)
+      client.lrem(normalize_key(key), count, value)
+    end
+
+    def destroy_first(key, limit = 1)
+      client.ltrim(normalize_key(key), limit, -1)
+    end
+
+    def destroy_last(key, limit = 1)
+      client.ltrim(normalize_key(key), 0, -(limit + 1))
+    end
+
+    def destroy_except(key, start, finish)
+      client.ltrim(normalize_key(key), (start - 1), (finish - 1))
+    end
+
+    def destroy_all(key)
+      client.ltrim(normalize_key(key), -1, 0)
+    end
+
+    def pop(key, order = :prepend)
+      value = append?(order) ? client.rpop(key) : client.lpop(key)
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def pop_blocking(keys, opts = {})
+      timeout = opts[:timeout] || 0
+      value = if append?(opts[:order] || :prepend)
+                client.brpop(keys, timeout)
+              else
+                client.blpop(keys, timeout)
+              end
+
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+  end
+end

data/lib/active_redis_db/pub_sub.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::PubSub < ActiveRedisDB::Base
+  class << self
+
+    def publish(channel, message)
+      client.publish(channel, message)
+    end
+
+    def subscribed?
+      client.subscribed?
+    end
+
+    def subscribe(*channels, &block)
+      client.subscribe(channels, &block)
+    end
+
+    def unsubscribe(*channels)
+      client.unsubscribe(channels)
+    end
+
+    def match_subscribe(*channels, &block)
+      client.psubscribe(channels, &block)
+    end
+
+    def match_unsubscribe(*channels)
+      client.punsubscribe(channels)
+    end
+
+    def state(command, *args)
+      client.pubsub(command, args)
+    end
+
+  end
+end

data/lib/active_redis_db/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::Railtie < Rails::Railtie
+
+  rake_tasks do
+    Dir[File.expand_path('tasks/*.rake', File.dirname(__FILE__))].each { |ext| load(ext) }
+  end
+
+end

data/lib/active_redis_db/script.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::Script < ActiveRedisDB::Base
+  class << self
+
+    def script(command, *args)
+      client.script(command, args)
+    end
+
+    def eval(*args)
+      client.eval(:eval, args)
+    end
+
+    def evalsha(*args)
+      client.eval(:evalsha, args)
+    end
+
+  end
+end

data/lib/active_redis_db/set.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::Set < ActiveRedisDB::Base
+  class << self
+
+    def find(key)
+      value = client.smembers(normalize_key(key))
+      metatransform(value)
+    end
+
+    def combine(*args)
+      value = client.sunion(*args)
+      metatransform(value)
+    end
+
+    def difference(*args)
+      value = client.sdiff(*args)
+      metatransform(value)
+    end
+
+    def intersection(key, *args)
+      value = client.sinter(normalize_key(key), *args)
+      metatransform(value)
+    end
+
+    def sample(key, value = 1)
+      value = client.srandmember(normalize_key(key), value)
+      metatransform(value)
+    end
+
+    def value?(key, value)
+      client.sismember(normalize_key(key), value)
+    end
+
+    def count(key)
+      client.scard(normalize_key(key))
+    end
+
+    def create(key, *args)
+      client.sadd(normalize_key(key), args)
+    end
+
+    def create_combination(key, *args)
+      client.sunionstore(normalize_key(key), args)
+    end
+
+    def create_difference(key, *args)
+      client.sdiffstore(normalize_key(key), *args)
+    end
+
+    def create_intersection(key, *args)
+      client.sinterstore(normalize_key(key), args)
+    end
+
+    def move(key, destination, value)
+      client.smove(normalize_key(key), destination.to_s, value)
+    end
+
+    def destroy(key, *args)
+      client.srem(normalize_key(key), *args)
+    end
+
+    def destroy_random(key)
+      client.spop(normalize_key(key))
+    end
+
+    def scan(key, cursor, opts = {})
+      client.sscan(normalize_key(key), cursor, opts)
+    end
+
+  end
+end

data/lib/active_redis_db/sorted_set.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::SortedSet < ActiveRedisDB::Base
+  class << self
+
+    def find(key, position, opts = {})
+      position -= 1
+
+      value = client.zrange(normalize_key(key), position, position, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def find_score(key, position, opts = {})
+      value = client.zrangebyscore(normalize_key(key), position, position, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first(key, opts = {})
+      value = client.zrange(normalize_key(key), 0, 0, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def first_score(key, opts = {})
+      value = client.zrangebyscore(normalize_key(key), 1, 1, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last(key, opts = {})
+      value = client.zrevrange(normalize_key(key), 0, 0, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def last_score(key, opts = {})
+      value = client.zrevrangebyscore(normalize_key(key), 1, 1, opts)
+      value = value.first
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def between(key, start, finish, opts = {})
+      value = client.zrange(normalize_key(key), (start - 1), (finish - 1), opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_reverse(key, start, finish, opts = {})
+      value = client.zrevrange(normalize_key(key), (start - 1), (finish - 1), opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_scores(key, min, max, opts = {})
+      value = client.zrangebyscore(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_scores_reverse(key, min, max, opts = {})
+      value = client.zrevrangebyscore(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_lex(key, min, max, opts = {})
+      value = client.zrangebylex(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def between_lex_reverse(key, min, max, opts = {})
+      value = client.zrevrangebylex(normalize_key(key), min, max, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def all(key, opts = {})
+      value = client.zrange(normalize_key(key), 0, -1, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def all_reverse(key, opts = {})
+      value = client.zrevrange(normalize_key(key), 0, -1, opts)
+      value = metatransform(value)
+      value
+    end
+
+    def position(key, value)
+      value = client.zrank(normalize_key(key), value)
+      value += 1 unless value.nil?
+      value
+    end
+
+    def position_reverse(key, value)
+      value = client.zrevrank(normalize_key(key), value)
+      value += 1 unless value.nil?
+      value
+    end
+
+    def score(key, value)
+      client.zscore(normalize_key(key), value)
+    end
+
+    def count(key)
+      client.zcard(normalize_key(key))
+    end
+
+    def count_between(key, min, max)
+      client.zcount(normalize_key(key), min, max)
+    end
+
+    def create(key, *args)
+      client.zadd(normalize_key(key), args)
+    end
+
+    def create_intersection(key, keys, opts = {})
+      client.zinterstore(normalize_key(key), keys, opts)
+    end
+
+    def create_combination(key, keys, opts = {})
+      client.zunionstore(normalize_key(key), keys, opts)
+    end
+
+    def increment(key, value, count)
+      client.zincrby(normalize_key(key), count, value)
+    end
+
+    def destroy(key, at)
+      client.zrem(normalize_key(key), at)
+    end
+
+    def destroy_between(key, start, finish)
+      client.zremrangebyrank(normalize_key(key), (start - 1), (finish - 1))
+    end
+
+    def destroy_scores(key, min, max)
+      client.zremrangebyscore(normalize_key(key), min, max)
+    end
+
+    def destroy_lex(key, min, max, opts = {})
+      client.zrevrangebylex(normalize_key(key), max, min, opts)
+    end
+
+    def scan(key, cursor, opts = {})
+      client.zscan(normalize_key(key), cursor, opts)
+    end
+
+  end
+end

data/lib/active_redis_db/string.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: false
+
+class ActiveRedisDB::String < ActiveRedisDB::Base
+  class << self
+
+    def find(key)
+      value = client.get(normalize_key(key))
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def find_each(*args)
+      args  = stringify_keys(args)
+      value = client.mget(args)
+      value = metamorph(value) if evaluate?
+      value
+    end
+
+    def length(key)
+      client.strlen(normalize_key(key))
+    end
+
+    def split(key, start, finish)
+      client.getrange(normalize_key(key), start, finish)
+    end
+
+    def create(key, value, opts = {})
+      client.set(normalize_key(key), value, opts)
+    end
+
+    def create!(key, value)
+      client.setnx(normalize_key(key), value)
+    end
+
+    def create_each(*args)
+      args = stringify_keys(args)
+      client.mset(args)
+    end
+
+    def create_each!(*args)
+      args = stringify_keys(args)
+      client.msetnx(args)
+    end
+
+    def create_until(key, value, seconds, format = :seconds)
+      normalized_key = normalize_key(key)
+
+      if seconds?(format)
+        client.setex(normalized_key, seconds, value)
+      else
+        client.psetex(normalized_key, seconds, value)
+      end
+    end
+
+    def append(key, value)
+      client.append(normalize_key(key), value)
+    end
+
+    def replace(key, value, offset)
+      client.setrange(normalize_key(key), offset, value)
+    end
+
+    def decrement(key, value = 1)
+      normalized_key = normalize_key(key)
+
+      value == 1 ? client.decr(normalized_key) : client.decrby(normalized_key, value)
+    end
+
+    def increment(key, value = 1)
+      normalized_key = normalize_key(key)
+
+      if value.is_a?(Float)
+        client.incrbyfloat(normalized_key, value)
+      else
+        value == 1 ? client.incr(normalized_key) : client.incrby(normalized_key, value)
+      end
+    end
+
+    def reset(key, value = 0)
+      client.getset(normalize_key(key), value)
+    end
+
+    def bit_count(key, start = 0, finish = -1)
+      client.bitcount(normalize_key(key), start, finish)
+    end
+
+    def bit_where(operation, key, *keys)
+      client.bitop(operation, key, *keys)
+    end
+
+    def get_bit(key, offset)
+      client.getbit(normalize_key(key), offset)
+    end
+
+    def set_bit(key, offset, bit)
+      client.setbit(normalize_key(key), offset, bit)
+    end
+
+  end
+end

data/lib/active_redis_db/transaction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class ActiveRedisDB::Transaction < ActiveRedisDB::Base
+  class << self
+
+    def discard
+      client.discard
+    end
+
+    def exec
+      client.exec
+    end
+
+    def multi(&block)
+      client.multi(&block)
+    end
+
+    def watch(*args)
+      client.watch(args)
+    end
+
+    def unwatch
+      client.unwatch
+    end
+
+  end
+end

data/lib/active_redis_db/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ActiveRedisDB
+  VERSION ||= '1.0.0'
+end

data/lib/active_redis_db.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+%w[
+  version railtie configuration base connection geo hash hyper_log_log
+  key list pub_sub script set sorted_set string transaction
+].each do |file_name|
+  require "active_redis_db/#{file_name}"
+end
+
+require 'generators/active_redis_db/install_generator'

data/lib/generators/active_redis_db/install_generator.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+class ActiveRedisDB::InstallGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_initializer_file
+    copy_file('install.rb', 'config/initializers/active_redis_db.rb')
+  end
+
+end

data/lib/generators/active_redis_db/templates/install.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+if defined?(Redis)
+  ActiveRedisDB.configure do |config|
+    config.client = Redis.new
+  end
+end