lite-redis 1.0.0

data/docs/STRING.md

@@ -0,0 +1,14 @@
+# String
+
+#### Usage
+
+Please read the corresponding [helper](https://github.com/drexed/lite-redis/blob/master/lib/lite/redis/helpers/string_helper.rb) file to see all available methods.
+
+Please read the corresponding [spec](https://github.com/drexed/lite-redis/blob/master/spec/lite/redis/string_spec.rb) file to see more example usages.
+
+```ruby
+string = Lite::Redis::String.new
+string.create(:example1, '123')     #=> 'OK'
+
+Lite::Redis::String.find(:example1) #=> '123'
+```

data/docs/TRANSACTION.md

@@ -0,0 +1,14 @@
+# Transaction
+
+#### Usage
+
+Please read the corresponding [helper](https://github.com/drexed/lite-redis/blob/master/lib/lite/redis/helpers/transaction_helper.rb) file to see all available methods.
+
+Please read the corresponding [spec](https://github.com/drexed/lite-redis/blob/master/spec/lite/redis/transaction_spec.rb) file to see more example usages.
+
+```ruby
+transaction = Lite::Redis::Transaction.new
+transaction.multi { |m| m.set('foo', 's1') } #=> 'OK'
+
+Lite::Redis::Transaction.discard             #=> 'OK'
+```

data/lib/generators/lite/redis/install_generator.rb

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

data/lib/generators/lite/redis/templates/install.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Lite::Redis.configure do |config|
+  config.client = Redis.new
+end

data/lib/lite/redis/base.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+    class Base
+
+      extend Lite::Redis::BaseHelper
+      include Lite::Redis::BaseHelper
+
+    end
+  end
+end

data/lib/lite/redis/configuration.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+
+    class Configuration
+
+      attr_accessor :client
+
+      def initialize
+        @client = ::Redis.new
+      end
+
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.configuration=(config)
+      @configuration = config
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+
+  end
+end

data/lib/lite/redis/connection.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+    class Connection < Lite::Redis::Base
+
+      extend Lite::Redis::ConnectionHelper
+      include Lite::Redis::ConnectionHelper
+
+    end
+  end
+end

data/lib/lite/redis/geo.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+    class Geo < Lite::Redis::Base
+
+      extend Lite::Redis::GeoHelper
+      include Lite::Redis::GeoHelper
+
+    end
+  end
+end

data/lib/lite/redis/hash.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+    class Hash < Lite::Redis::Base
+
+      extend Lite::Redis::HashHelper
+      include Lite::Redis::HashHelper
+
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+    module BaseHelper
+
+      def initialize(redis = nil)
+        @client = redis
+      end
+
+      def client(redis = nil)
+        @client ||= redis ||= Lite::Redis.configuration.client
+      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
+end

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

@@ -0,0 +1,105 @@
+# 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

@@ -0,0 +1,33 @@
+# 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

@@ -0,0 +1,69 @@
+# 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

@@ -0,0 +1,21 @@
+# 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

@@ -0,0 +1,95 @@
+# 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

@@ -0,0 +1,133 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,21 @@
+# 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