lite-redis 1.0.0

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

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

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

@@ -0,0 +1,98 @@
+# 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)
+        if value.is_a?(Float)
+          client.incrbyfloat(key.to_s, value)
+        elsif value == 1
+          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

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

data/lib/lite/redis/hyper_log_log.rb

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

data/lib/lite/redis/key.rb

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

data/lib/lite/redis/list.rb

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

data/lib/lite/redis/pub_sub.rb

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

data/lib/lite/redis/railtie.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+
+module Lite
+  module Redis
+    class Railtie < ::Rails::Railtie
+
+      rake_tasks do
+        path = File.expand_path('../../tasks/*.rake', __FILE__)
+        Dir.each_child(path) { |filename| load(filename) }
+      end
+
+    end
+  end
+end

data/lib/lite/redis/script.rb

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

data/lib/lite/redis/set.rb

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

data/lib/lite/redis/sorted_set.rb

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

data/lib/lite/redis/string.rb

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

data/lib/lite/redis/transaction.rb

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

data/lib/lite/redis/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Lite
+  module Redis
+
+    VERSION ||= '1.0.0'
+
+  end
+end

data/lib/lite/redis.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'redis'
+
+require 'lite/redis/version'
+require 'lite/redis/railtie' if defined?(Rails)
+require 'lite/redis/configuration'
+
+%w[
+  base connection geo hash hyper_log_log key list pub_sub script set sorted_set string transaction
+].each do |file_name|
+  require "lite/redis/helpers/#{file_name}_helper"
+  require "lite/redis/#{file_name}"
+end
+
+require 'generators/lite/redis/install_generator'

data/lib/tasks/redis.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+namespace :db do
+  namespace :redis do
+    desc 'Reset Redis database'
+    task reset: :environment do
+      puts '== Reset: reseting Redis '.ljust(80, '=')
+      total_task_start_time = Time.current
+
+      puts '  -> Resetting'
+      Lite::Redis::Connection.flush
+
+      total_task_elapsed_time = (Time.current - total_task_start_time).round(5)
+      puts "== Reset: reset Redis (#{total_task_elapsed_time}s) ".ljust(80, '=')
+      puts ''
+    end
+
+    desc 'Reset all Redis databases'
+    task reset_all: :environment do
+      puts '== Reset: reseting all Redis '.ljust(80, '=')
+      total_task_start_time = Time.current
+
+      puts '  -> Resetting'
+      Lite::Redis::Connection.flush_all
+
+      total_task_elapsed_time = (Time.current - total_task_start_time).round(5)
+      puts "== Reset: reset all Redis (#{total_task_elapsed_time}s) ".ljust(80, '=')
+      puts ''
+    end
+  end
+end

data/lite-redis.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lite/redis/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'lite-redis'
+  spec.version = Lite::Redis::VERSION
+  spec.authors = ['Juan Gomez']
+  spec.email = %w[j.gomez@drexed.com]
+
+  spec.summary = 'Access Redis with an ActiveRecord like ORM interface'
+  spec.homepage = 'http://drexed.github.io/lite-redis'
+  spec.license = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata.merge(
+      'allowed_push_host' => 'https://rubygems.org',
+      'changelog_uri' => 'https://github.com/drexed/lite-redis/blob/master/CHANGELOG.md',
+      'homepage_uri' => spec.homepage,
+      'source_code_uri' => 'https://github.com/drexed/lite-redis'
+    )
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against ' \
+      'public gem pushes.'
+  end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = %w[lib]
+
+  spec.add_runtime_dependency 'redis'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'connection_pool'
+  spec.add_development_dependency 'fakeredis'
+  spec.add_development_dependency 'fasterer'
+  spec.add_development_dependency 'generator_spec'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'rubocop-rspec'
+end