lite-redis 1.1.2 → 1.3.0

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module ConnectionHelper
-
-      def authenticate(password)
-        client.auth(password)
-      end
-
-      def connected?
-        client.connected?
-      end
-
-      def database(index)
-        client.select(index)
-      end
-
-      def database_id
-        client.database_id
-      end
-
-      def database_size
-        client.dbsize
-      end
-
-      def debug(*args)
-        client.debug(*args)
-      end
-
-      def disconnect
-        client.disconnect
-      end
-
-      def echo(message)
-        client.echo(message)
-      end
-
-      def flush
-        client.flushdb
-      end
-
-      def flush_all
-        client.flushall
-      end
-
-      def info
-        client.info
-      end
-
-      def ping
-        client.ping
-      end
-
-      def quit
-        client.quit
-      end
-
-      def reconnect
-        client.reconnect
-      end
-
-      def rewrite_aof
-        client.bgrewriteaof
-      end
-
-      def save
-        client.bgsave
-      end
-
-      def saved_at
-        client.lastsave
-      end
-
-      def shutdown
-        client.shutdown
-      end
-
-      def slave_of(host, port)
-        client.slaveof(host, port)
-      end
-
-      def slowlog(command, length = nil)
-        client.slowlog(command, length)
-      end
-
-      def synchronize
-        client.synchronize
-      end
-
-      def time
-        client.time
-      end
-
-      def with_reconnect(&block)
-        client.with_reconnect(true, &block)
-      end
-
-      def without_reconnect(&block)
-        client.with_reconnect(false, &block)
-      end
-
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module Lite
-  module Redis
-    module GeoHelper
-
-      def create(key, *member)
-        client.geoadd(key.to_s, *member)
-      end
-
-      def hash(key, member)
-        client.geohash(key.to_s, member)
-      end
-
-      def position(key, member)
-        client.geopos(key.to_s, member)
-      end
-
-      def distance(key, member1, member2, unit = 'm')
-        client.geodist(key.to_s, member1, member2, unit.to_s)
-      end
-
-      def radius(*args, **geoptions)
-        client.georadius(*args, **geoptions)
-      end
-
-      def radius_member(*args, **geoptions)
-        client.georadiusbymember(*args, **geoptions)
-      end
-
-    end
-  end
-end

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