lite-redis 1.2.0 → 1.3.0

data/lib/lite/redis/base.rb

@@ -4,8 +4,59 @@ module Lite
   module Redis
     class Base
 
-      extend Lite::Redis::BaseHelper
-      include Lite::Redis::BaseHelper
+      attr_writer :client
+
+      def initialize(redis = nil)
+        @client = redis
+      end
+
+      class << self
+
+        def method_missing(method_name, *args, **kwargs, &block)
+          instance = new
+
+          if instance.respond_to_method?(method_name)
+            instance.send(method_name, *args, **kwargs, &block)
+          else
+            super
+          end
+        end
+
+      end
+
+      def client
+        @client ||= Lite::Redis.configuration.client
+      end
+
+      def respond_to_method?(method_name)
+        public_methods.include?(method_name)
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        respond_to_method?(method_name) || super
+      end
+
+      private
+
+      def append?(order)
+        order.to_s == "append"
+      end
+
+      def milliseconds?(format)
+        format.to_s == "milliseconds"
+      end
+
+      def prepend?(order)
+        order.to_s == "prepend"
+      end
+
+      def seconds?(format)
+        format.to_s == "seconds"
+      end
+
+      def stringify_keys(*keys)
+        keys.map { |key, _| key.to_s }
+      end
 
     end
   end

data/lib/lite/redis/configuration.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "redis" unless defined?(Redis)
+
 module Lite
   module Redis
 

data/lib/lite/redis/connection.rb

@@ -2,10 +2,103 @@
 
 module Lite
   module Redis
-    class Connection < Lite::Redis::Base
+    class Connection < Base
 
-      extend Lite::Redis::ConnectionHelper
-      include Lite::Redis::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

data/lib/lite/redis/geo.rb

@@ -2,10 +2,31 @@
 
 module Lite
   module Redis
-    class Geo < Lite::Redis::Base
+    class Geo < Base
 
-      extend Lite::Redis::GeoHelper
-      include Lite::Redis::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

data/lib/lite/redis/hash.rb

@@ -2,10 +2,67 @@
 
 module Lite
   module Redis
-    class Hash < Lite::Redis::Base
+    class Hash < Base
 
-      extend Lite::Redis::HashHelper
-      include Lite::Redis::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

data/lib/lite/redis/hyper_log_log.rb

@@ -2,10 +2,19 @@
 
 module Lite
   module Redis
-    class HyperLogLog < Lite::Redis::Base
+    class HyperLogLog < Base
 
-      extend Lite::Redis::HyperLogLogHelper
-      include Lite::Redis::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

data/lib/lite/redis/key.rb

@@ -2,10 +2,93 @@
 
 module Lite
   module Redis
-    class Key < Lite::Redis::Base
+    class Key < Base
 
-      extend Lite::Redis::KeyHelper
-      include Lite::Redis::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

data/lib/lite/redis/list.rb

@@ -2,10 +2,131 @@
 
 module Lite
   module Redis
-    class List < Lite::Redis::Base
+    class List < Base
 
-      extend Lite::Redis::ListHelper
-      include Lite::Redis::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

data/lib/lite/redis/pub_sub.rb

@@ -2,10 +2,43 @@
 
 module Lite
   module Redis
-    class PubSub < Lite::Redis::Base
+    class PubSub < Base
 
-      extend Lite::Redis::PubSubHelper
-      include Lite::Redis::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

data/lib/lite/redis/railtie.rb

@@ -5,7 +5,7 @@ module Lite
     class Railtie < Rails::Railtie
 
       rake_tasks do
-        file = File.expand_path('../../../tasks/redis.rake', __FILE__)
+        file = File.expand_path("../../../tasks/redis.rake", __FILE__)
         load(file)
       end
 

data/lib/lite/redis/script.rb

@@ -2,10 +2,19 @@
 
 module Lite
   module Redis
-    class Script < Lite::Redis::Base
+    class Script < Base
 
-      extend Lite::Redis::ScriptHelper
-      include Lite::Redis::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

data/lib/lite/redis/set.rb

@@ -2,10 +2,67 @@
 
 module Lite
   module Redis
-    class Set < Lite::Redis::Base
+    class Set < Base
 
-      extend Lite::Redis::SetHelper
-      include Lite::Redis::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