lite-redis 1.2.0 → 1.3.0

data/lib/lite/redis/helpers/hash_helper.rb

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module HashHelper
-
-      def find(key, field)
-        client.hget(key.to_s, field)
-      end
-
-      def find_each(key, *args)
-        client.hmget(key.to_s, *args)
-      end
-
-      def all(key)
-        client.hgetall(key.to_s)
-      end
-
-      def keys(key)
-        client.hkeys(key.to_s)
-      end
-
-      def values(key)
-        client.hvals(key.to_s)
-      end
-
-      def value_length(key, field)
-        client.hstrlen(key.to_s, field)
-      end
-
-      def count(key)
-        client.hlen(key.to_s)
-      end
-
-      def exists?(key, field)
-        client.hexists(key.to_s, field)
-      end
-
-      def create(key, field, value)
-        client.hset(key.to_s, field, value)
-      end
-
-      def create!(key, field, value)
-        client.hsetnx(key.to_s, field, value)
-      end
-
-      def create_each(key, *args)
-        client.hmset(key.to_s, *args)
-      end
-
-      def increment(key, field, value)
-        if value.is_a?(Float)
-          client.hincrbyfloat(key.to_s, field, value)
-        else
-          client.hincrby(key.to_s, field, value)
-        end
-      end
-
-      def destroy(key, *args)
-        client.hdel(key.to_s, *args)
-      end
-
-      def scan(key, cursor, opts = {})
-        client.hdel(key.to_s, cursor, **opts)
-      end
-
-    end
-  end
-end

data/lib/lite/redis/helpers/hyper_log_log_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module HyperLogLogHelper
-
-      def create(key, member)
-        client.pfadd(key.to_s, member)
-      end
-
-      def count(*args)
-        client.pfcount(*args)
-      end
-
-      def merge(key, *keys)
-        client.pfmerge(key.to_s, *keys)
-      end
-
-    end
-  end
-end

data/lib/lite/redis/helpers/key_helper.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module KeyHelper
-
-      def exists?(key)
-        client.exists(key.to_s)
-      end
-
-      def type?(key)
-        client.type(key.to_s)
-      end
-
-      def ttl?(key, format = :seconds)
-        if seconds?(format)
-          client.ttl(key.to_s)
-        else
-          client.pttl(key.to_s)
-        end
-      end
-
-      def sort(key, opts = {})
-        client.sort(key.to_s, **opts)
-      end
-
-      def sample
-        client.randomkey
-      end
-
-      def rename(key, value)
-        client.rename(key.to_s, value.to_s)
-      end
-
-      def rename!(key, value)
-        client.renamenx(key.to_s, value.to_s)
-      end
-
-      def destroy(key)
-        client.del(key.to_s)
-      end
-
-      def persist(key)
-        client.persist(key.to_s)
-      end
-
-      def expire(key, seconds, format = :seconds)
-        if seconds?(format)
-          client.expire(key.to_s, seconds)
-        else
-          client.pexpire(key.to_s, seconds)
-        end
-      end
-
-      alias expire_in expire
-
-      def expire_at(key, seconds, format = :seconds)
-        if seconds?(format)
-          client.expireat(key.to_s, seconds)
-        else
-          client.pexpireat(key.to_s, seconds)
-        end
-      end
-
-      def dump(key)
-        client.dump(key.to_s)
-      end
-
-      def match(pattern = '*')
-        client.keys(pattern.to_s)
-      end
-
-      def migrate(key, options)
-        client.migrate(key.to_s, options)
-      end
-
-      def move(key, destination)
-        client.move(key.to_s, destination)
-      end
-
-      def object(*args)
-        client.object(*args)
-      end
-
-      def restore(key, milliseconds, value)
-        client.restore(key.to_s, milliseconds, value)
-      end
-
-      def scan(cursor, opts = {})
-        client.scan(cursor, **opts)
-      end
-
-    end
-  end
-end

data/lib/lite/redis/helpers/list_helper.rb

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

data/lib/lite/redis/helpers/pub_sub_helper.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module PubSubHelper
-
-      def publish(channel, message)
-        client.publish(channel, message)
-      end
-
-      def subscribed?
-        client.subscribed?
-      end
-
-      def subscribe(*channels, timeout: nil, &block)
-        if timeout.nil?
-          client.subscribe(*channels, &block)
-        else
-          client.subscribe_with_timeout(timeout, *channels, &block)
-        end
-      end
-
-      def unsubscribe(*channels)
-        client.unsubscribe(*channels)
-      end
-
-      def match_subscribe(*channels, timeout: nil, &block)
-        if timeout.nil?
-          client.psubscribe(*channels, &block)
-        else
-          client.psubscribe_with_timeout(timeout, *channels, &block)
-        end
-      end
-
-      def match_unsubscribe(*channels)
-        client.punsubscribe(*channels)
-      end
-
-      def state(command, *args)
-        client.pubsub(command, *args)
-      end
-
-    end
-  end
-end

data/lib/lite/redis/helpers/script_helper.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module ScriptHelper
-
-      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
-end

data/lib/lite/redis/helpers/set_helper.rb

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

data/lib/lite/redis/helpers/sorted_set_helper.rb

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

data/lib/lite/redis/helpers/string_helper.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module StringHelper
-
-      def find(key)
-        client.get(key.to_s)
-      end
-
-      def find_each(*args)
-        args = stringify_keys(*args)
-        client.mget(args)
-      end
-
-      def length(key)
-        client.strlen(key.to_s)
-      end
-
-      def split(key, start, finish)
-        client.getrange(key.to_s, start, finish)
-      end
-
-      def create(key, value, opts = {})
-        client.set(key.to_s, value, **opts)
-      end
-
-      def create!(key, value)
-        client.setnx(key.to_s, 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)
-        if seconds?(format)
-          client.setex(key.to_s, seconds, value)
-        else
-          client.psetex(key.to_s, seconds, value)
-        end
-      end
-
-      def append(key, value)
-        client.append(key.to_s, value)
-      end
-
-      def replace(key, value, offset)
-        client.setrange(key.to_s, offset, value)
-      end
-
-      def decrement(key, value = 1)
-        if value == 1
-          client.decr(key.to_s)
-        else
-          client.decrby(key.to_s, value)
-        end
-      end
-
-      def increment(key, value = 1)
-        case value
-        when Float then client.incrbyfloat(key.to_s, value)
-        when 1 then client.incr(key.to_s)
-        else client.incrby(key.to_s, value)
-        end
-      end
-
-      def reset(key, value = 0)
-        client.getset(key.to_s, value)
-      end
-
-      def bit_count(key, start = 0, finish = -1)
-        client.bitcount(key.to_s, start, finish)
-      end
-
-      def bit_where(operation, key, *keys)
-        client.bitop(operation, key, *keys)
-      end
-
-      def get_bit(key, offset)
-        client.getbit(key.to_s, offset)
-      end
-
-      def set_bit(key, offset, bit)
-        client.setbit(key.to_s, offset, bit)
-      end
-
-    end
-  end
-end

data/lib/lite/redis/helpers/transaction_helper.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module TransactionHelper
-
-      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
-end