redis_rds 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fe5fdbd19701e3212b3dd6f36b9ccb7717ab60d9
+  data.tar.gz: fbe1a8aa69abecd838a8659a3175114135c67afb
+SHA512:
+  metadata.gz: 6fab513e4524e3ef4375540a52fac2f7efac0a77b2bd7fc7c9a0a12e0cfacc0a8fcb2adbd0921ccb27a67d07a69de9d07261ec566551bc29218597544be3a8f1
+  data.tar.gz: 72cae17306552b4f7807f4163caee1950d73eac99d99be99ff61abbf096d3178eed31ac0479120ab3ca69b5802ef1435b952119749e2c9f93a3088709db483a2

data/.coveralls.yml

@@ -0,0 +1,2 @@
+service_name: travis-ci
+

data/.gitignore

@@ -0,0 +1,18 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/
+
+# ignore vim tmp and swap files
+*~
+*.swp
+*.swo
+
+.DS_Store
+.rubocop-*
+redis_rds.sublime-workspace
+README.md-u

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_from:
+  - https://raw.githubusercontent.com/barcoo/barcoop/master/rubocop.yml

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.2
+  - 2.1
+services:
+  - redis-server
+before_install: gem install bundler -v 1.12.5

data/CHANGELOG.md

@@ -0,0 +1,29 @@
+# Changelog
+
+##0.1.1
+
+- [6617250](https://github.com/barcoo/redis_rds/commit/6617250) *2016-07-24* __move tests to test/redis_rds__ (Sergio Medina)
+- [48d8c0b](https://github.com/barcoo/redis_rds/commit/48d8c0b) *2016-07-24* __run tests in random order__ (Sergio Medina)
+- [2fe8944](https://github.com/barcoo/redis_rds/commit/2fe8944) *2016-07-24* __require only active record core extensions__ (Sergio Medina)
+- [9cf87a8](https://github.com/barcoo/redis_rds/commit/9cf87a8) *2016-07-24* __ignore vim temp and swap files__ (Sergio Medina)
+- [96b541b](https://github.com/barcoo/redis_rds/commit/96b541b) *2016-07-23* __drop rails dependency and use default bundler gem scaffolding__ (Sergio Medina)
+- [2cce40e](https://github.com/barcoo/redis_rds/commit/2cce40e) *2016-07-19* __fix broken link__ (Sergio Medina)
+- [9afe525](https://github.com/barcoo/redis_rds/commit/9afe525) *2016-07-19* __build status added, removing it from the roadmap__ (Sergio Medina)
+- [aecb26b](https://github.com/barcoo/redis_rds/commit/aecb26b) *2016-07-19* __use travis badge for master branch__ (Sergio Medina)
+- [db3ffb2](https://github.com/barcoo/redis_rds/commit/db3ffb2) *2016-07-19* __add travis CI config__ (Sergio Medina)
+- [0dc4578](https://github.com/barcoo/redis_rds/commit/0dc4578) *2016-07-19* __move RedisSingleton.clear_test_db to setup in test_helper__ (Sergio Medina)
+
+##0.1.0
+
+- [b97c0c4](https://github.com/barcoo/redis_rds/commit/b97c0c4) *2016-07-18* __bump version to 0.1.0__ (Sergio Medina)
+- [4a29c74](https://github.com/barcoo/redis_rds/commit/4a29c74) *2016-07-18* __remove configuration through YAML files__ (Sergio Medina)
+- [c8534b3](https://github.com/barcoo/redis_rds/commit/c8534b3) *2016-07-18* __small changes to Roadmap__ (Sergio Medina)
+
+##0.0.4
+
+
+
+##0.0.3
+
+- [6dd41ea](https://github.com/barcoo/redis_rds/commit/6dd41ea) *2016-07-17* __version bump__ (Sergio Medina)
+- [0431cd1](https://github.com/barcoo/redis_rds/commit/0431cd1) *2016-07-17* __ignore README.md-u__ (Sergio Medina)

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in redis_rds.gemspec
+gemspec
+
+gem 'simplecov', require: false, group: :test
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Checkitmobile GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+# RedisRds
+
+[![GitHub release](https://img.shields.io/badge/release-0.1.1-blue.png)](https://github.com/barcoo/redis_rds/releases/tag/0.1.1)
+[![Build Status](https://travis-ci.org/barcoo/redis_rds.svg?branch=master)](https://travis-ci.org/barcoo/redis_rds)
+[![Coverage Status](https://coveralls.io/repos/github/barcoo/redis_rds/badge.svg?branch=master&update=now)](https://coveralls.io/github/barcoo/redis_rds?branch=master)
+
+Ruby data structures stored in Redis.
+
+RedisRds provides Redis-backed Ruby interfaces for the following data structures:
+
+* String
+* Hash
+* ExpirableHash
+* NestedHash
+* List
+* Mutex
+* Set
+* SortedSet
+* SortedStringSet
+
+## Installation
+
+Add to your gemfile:
+
+```ruby
+gem 'redis_rds', git: 'git@github.com:barcoo/redis_rds.git'
+```
+
+## Usage
+
+Best is to check [the tests](test/) to see how to use the data structures.
+Here are two examples, for Mutex and String:
+
+```ruby
+# configure RedisRds by passing either a connection
+RedisRds.configure(connection: my_redis_connection, namespace: 'my_app')
+# or connection parameters
+RedisRds.configure(
+  host: 'localhost',
+  db: 1,
+  port: 6379,
+  namespace: 'my_app',
+)
+```
+
+```ruby
+my_semaphore = RedisRds::Mutex.new('a_key')
+my_semaphore.synchronize do
+  # do something with a shared resource
+  write_file()
+end # mutex released, another thread can use the resource
+```
+
+```ruby
+string_a = RedisRds::String.new('some_key')
+string_a = 'hello'
+
+string_b = RedisRds::String.new('some_key')
+puts string_b
+# 'hello'
+```
+
+## Contributing
+
+Take a look at the [Roadmap](doc/ROADMAP.md) and lint your code using [rubocop](https://github.com/bbatsov/rubocop) and our [rubocop.yml](.rubocop.yml) file.
+
+To run the tests, start a Redis server on localhost and run `bundle exec rake test`.
+
+To contribute:
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Release
+
+___Note___: eventually use one of the popular git release scripts to tag, create tag notes, etc., based on git changelog.
+
+When you want to create a new release, use the rake task ```cim:release``` (in the main Rakefile)
+
+```shell
+bundle exec rake cim:release
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,99 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test
+
+namespace :cim do
+  desc 'Tags, updates README, and CHANGELOG and pushes to Github. Requires ruby-git'
+  task :release do
+    tasks = ['cim:assert_clean_repo', 'cim:git_fetch', 'cim:assert_version', 'cim:update_readme', 'cim:update_changelog', 'cim:commit_changes', 'cim:tag']
+    begin
+      tasks.each { |task| Rake::Task[task].invoke }
+      `git push && git push origin '#{RedisRds::VERSION}'`
+    rescue => error
+      puts ">>> ERROR: #{error}; might want to reset your repository"
+    end
+  end
+
+  desc 'Fails if the current repository is not clean'
+  task :assert_clean_repo do
+    status = `git status -s`.chomp.strip
+    if status.empty?
+      status = `git log origin/master..HEAD`.chomp.strip # check if we have unpushed commits
+      if status.empty?
+        puts '>>> Repository is clean!'
+      else
+        puts '>>> Please push your committed changes before releasing!'
+        exit -1
+      end
+    else
+      puts '>>> Please stash or commit your changes before releasing!'
+      exit -1
+    end
+  end
+
+  desc 'Fetches latest tags/commits'
+  task :git_fetch do
+    puts '>>> Fetching latest git refs'
+    `git fetch --tags`
+  end
+
+  desc 'Fails if the current gem version is not greater than the last tag'
+  task :assert_version do
+    latest = `git describe --abbrev=0`.chomp.strip
+    current = RedisRds::VERSION
+
+    unless Gem::Version.new(current) > Gem::Version.new(latest)
+      puts ">>> Latest tagged version is #{latest}; make sure gem version (#{current}) is greater!"
+      exit -1
+    end
+  end
+
+  desc 'Updates README with latest version'
+  task :update_readme do
+    puts '>>> Updating README.md'
+    replace = %([![GitHub release](https://img.shields.io/badge/release-#{RedisRds::VERSION}-blue.png)](https://github.com/barcoo/redis_rds/releases/tag/#{RedisRds::VERSION}))
+
+    `sed -i -u 's@^\\[\\!\\[GitHub release\\].*$@#{replace}@' README.md`
+  end
+
+  desc 'Updates CHANGELOG with commit log from last tag to this one'
+  task :update_changelog do
+    puts '>>> Updating CHANGELOG.md'
+    latest = `git describe --abbrev=0`.chomp.strip
+    log = `git log --pretty=format:'- [%h](https://github.com/barcoo/redis_rds/commit/%h) *%ad* __%s__ (%an)' --date=short '#{latest}'..HEAD`.chomp
+
+    changelog = File.open('.CHANGELOG.md', 'w')
+    changelog.write("# Changelog\n\n###{RedisRds::VERSION}\n\n#{log}\n\n")
+    File.open('CHANGELOG.md', 'r') do |file|
+      file.readline # skip first two lines
+      file.readline
+      while buffer = file.read(2048)
+        changelog.write(buffer)
+      end
+    end
+
+    changelog.close
+    `mv '.CHANGELOG.md' 'CHANGELOG.md'`
+  end
+
+  desc 'Commits the README/CHANGELOG changes'
+  task :commit_changes do
+    puts '>>> Committing updates to README/CHANGELOG'
+    `git commit -am'Updated README.md and CHANGELOG.md on new release'`
+  end
+
+  desc 'Creates and pushes the tag to git'
+  task :tag do
+    puts '>>> Tagging'
+    message = STDOUT.print '>>> Please enter a tag message: '
+    input = STDIN.gets.strip.tr("'", "\'")
+    `git tag -a '#{RedisRds::VERSION}' -m '#{input}'`
+  end
+end

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'redis_rds'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/doc/ROADMAP.md

@@ -0,0 +1,10 @@
+# Roadmap
+
+- Add to RubyGems
+- Remove ActiveSupport dependency
+- Add documentation (use yard)
+- Add support for Redis authentication (or simply remove config by params and only accept a connection?)
+- Implement lazy enumerators (see Hash for instance)
+- Improve lib configuration (use Configuration class, allow multiple instances)
+- Use hashes for optional parameters (f.i. see Mutex::initialize)
+- Add support for latest Redis commands (f.i. Geospatial commands)

data/lib/redis_rds/composite.rb

@@ -0,0 +1,46 @@
+module RedisRds
+  class Composite
+    extend Forwardable
+
+    attr_reader :members
+    def_delegators :@members, :[], :[]=, :assoc, :size, :empty?, :each, :include?, :length, :merge
+
+    def initialize(key)
+      @key = key
+      @members = {}.with_indifferent_access
+    end
+
+    def add(key, klass)
+      object = klass.new(format_member_key(key))
+      @members[key] = object
+    end
+
+    def format_member_key(key)
+      return "#{@key}:#{key}"
+    end
+    private :format_member_key
+
+    def delete(key)
+      if @members.key?(key)
+        @members[key].delete
+        @members.delete(key)
+      end
+    end
+
+    def clear
+      @members.each do |k, _|
+        self.delete(k)
+      end
+      @members.clear
+    end
+
+    def method_missing(*args)
+      result = nil
+
+      key = args.first
+      result = @members[key] if key.present?
+
+      return result
+    end
+  end
+end

data/lib/redis_rds/config.rb

@@ -0,0 +1,36 @@
+require 'yaml'
+require 'redis'
+
+module RedisRds
+  # Configuration defaults
+  @config = {
+    host: 'localhost',
+    db: 1,
+    port: 6379,
+    timeout: 30,
+    thread_safe: true,
+    # FIXME: add username and password
+    namespace: 'testns',
+    connection: nil
+  }
+
+  @valid_config_keys = @config.keys
+
+  # Configure through hash
+  def self.configure(opts = {})
+    opts.each { |k, v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym }
+
+    if opts[:connection].present?
+      connection = opts[:connection]
+    else
+      config[:db] = config[:db].to_i
+      connection = Redis.new(config)
+    end
+
+    RedisRds::Object.configure(connection: connection, namespace: opts[:namespace])
+  end
+
+  def self.config
+    @config
+  end
+end

data/lib/redis_rds/expirable_hash.rb

@@ -0,0 +1,61 @@
+module RedisRds
+  class ExpirableHash < RedisRds::Hash
+    EXPIRY_KEY_SUFFIX = '__expiry__'.freeze
+
+    def get(key)
+      result = nil
+      value, expires_at = connection.hmget(@redis_key, key, expiry_key(key))
+      if expired?(expires_at)
+        remove(key)
+      else
+        result = value
+      end
+
+      return result
+    end
+
+    def set(key, value)
+      connection.multi do |redis|
+        redis.hset(@redis_key, key, value)
+        redis.hdel(@redis_key, expiry_key(key))
+      end
+    end
+
+    def setex(key, value, expiry)
+      expires_at = Time.now.to_i + expiry
+      connection.hmset(@redis_key, key, value, expiry_key(key), expires_at)
+    end
+
+    def expiry_key(key)
+      return "#{key}#{EXPIRY_KEY_SUFFIX}"
+    end
+
+    def remove(key)
+      connection.multi do |redis|
+        redis.hdel(@redis_key, key)
+        redis.hdel(@redis_key, expiry_key(key))
+      end
+    end
+
+    def all
+      hash = ::Hash[super().group_by do |key, _value|
+        if key.ends_with?(EXPIRY_KEY_SUFFIX)
+          key[0...(key.length - EXPIRY_KEY_SUFFIX.length)]
+        else
+          key
+        end
+      end.map { |key, values| [key, values.map(&:second)] }]
+
+      expired, valid = hash.partition { |_key, values| expired?(values.second) }
+      expired.each { |key, _| remove(key) }
+
+      return ::Hash[valid.map { |key, values| [key, values.first] }]
+    end
+
+    def expired?(expires_at)
+      return false if expires_at.nil?
+      return Time.now.to_i >= expires_at.to_i
+    end
+    private :expired?
+  end
+end

data/lib/redis_rds/hash.rb

@@ -0,0 +1,76 @@
+module RedisRds
+  class Hash < RedisRds::Object
+    include Enumerable
+
+    def get(key)
+      return connection.hget(@redis_key, key)
+    end
+    alias [] get
+
+    def set(key, value)
+      return connection.hset(@redis_key, key, value)
+    end
+    alias []= set
+
+    def mset(*args)
+      return connection.hmset(@redis_key, *args)
+    end
+
+    def mget(*_args)
+      return connection.hmget(@redis_key, *arg)
+    end
+
+    def setnx(key, value)
+      return connection.hsetnx(@redis_key, key, value)
+    end
+
+    def remove(key)
+      return connection.hdel(@redis_key, key)
+    end
+
+    def incrby(key, increment)
+      return connection.hincrby(@redis_key, key, increment)
+    end
+
+    def key?(key)
+      return connection.hexists(@redis_key, key)
+    end
+
+    def incr(key)
+      return incrby(key, 1)
+    end
+
+    def decr(key)
+      return incrby(key, -1)
+    end
+
+    def decrby(key, decrement)
+      return incrby(key, -decrement)
+    end
+
+    def all
+      return (getall || {}).with_indifferent_access
+    end
+
+    def getall
+      return connection.hgetall(@redis_key)
+    end
+
+    def values
+      return all.values
+    end
+
+    def keys
+      return all.keys
+    end
+
+    def to_json
+      return all.to_json
+    end
+
+    # TODO: Implement lazy enumerator
+    def each(&block)
+      return all.each(&block)
+    end
+  end
+end

data/lib/redis_rds/list.rb

@@ -0,0 +1,50 @@
+module RedisRds
+  class List < RedisRds::Object
+    include Enumerable
+
+    def size
+      return connection.llen(@redis_key)
+    end
+
+    def empty?
+      return self.size == 0 # rubocop:disable Style/ZeroLengthPredicate
+    end
+
+    def get(start, stop = -1)
+      return connection.lrange(@redis_key, start, stop)
+    end
+
+    def rpush(elems)
+      return connection.rpush(@redis_key, Array.wrap(elems))
+    end
+
+    def lpush(elems)
+      return connection.lpush(@redis_key, Array.wrap(elems))
+    end
+
+    def lpop(length = 1, force = false)
+      lua_script = "
+        local length = tonumber(ARGV[1]);
+        if (ARGV[2] ~= 'true' or redis.call('llen', KEYS[1])>=length) then
+          local result = redis.call('lrange', KEYS[1], 0, length - 1);
+          redis.call('ltrim', KEYS[1], length, - 1);
+          return result
+        else return ''
+        end"
+      result = connection.eval(lua_script, [@redis_key], [length, force])
+      result = [] if result.blank?
+
+      return result
+    end
+
+    def each(&block)
+      return get(0).each(&block)
+    end
+
+    def clear
+      # if start > end redis clears the list
+      # http://redis.io/commands/ltrim
+      return connection.ltrim(@redis_key, 1, 0)
+    end
+  end
+end

data/lib/redis_rds/mutex.rb

@@ -0,0 +1,56 @@
+module RedisRds
+  class Mutex < RedisRds::String
+    DEFAULT_EXPIRY = 60.seconds
+
+    attr_reader :id, :expiry
+
+    def initialize(id, expiry = DEFAULT_EXPIRY, owner = '')
+      super("#{namespace}:mutex:#{id}")
+
+      @id = id
+      @expiry = expiry
+      @owner = owner.blank? ? generate_owner : owner
+    end
+
+    def lock
+      connection.set(@redis_key, @owner, ex: @expiry, nx: true)
+      return locked?
+    end
+
+    def locked?
+      return connection.get(@redis_key) == @owner
+    end
+    alias owned? locked?
+
+    def release
+      self.delete if owned?
+    end
+
+    def serialize
+      [@id, @expiry, @owner]
+    end
+
+    def synchronize
+      if self.lock
+        begin
+          yield if block_given?
+        ensure
+          self.release
+        end
+      end
+    end
+
+    def generate_owner
+      now = Time.now.to_f
+      random = Random.new(now)
+      return Digest::MD5.hexdigest(random.rand(now).to_s)
+    end
+    private :generate_owner
+
+    class << self
+      def unserialize(serialized)
+        return self.new(*serialized)
+      end
+    end
+  end
+end

data/lib/redis_rds/nested_hash.rb

@@ -0,0 +1,38 @@
+module RedisRds
+  class NestedHash < RedisRds::Hash
+    SEPARATOR = ':'.freeze
+
+    def setnx(*keys, value)
+      return super(format_key(keys), value)
+    end
+
+    def incrby(*keys, increment)
+      return super(format_key(keys), increment)
+    end
+
+    def key?(_key)
+      return super(format_key(keys))
+    end
+
+    def get(*keys)
+      super(format_key(keys))
+    end
+
+    def set(*keys, value)
+      super(format_key(keys), value)
+    end
+
+    def setex(*keys, value, expiry)
+      super(format_key(keys), value, expiry)
+    end
+
+    def remove(*keys)
+      super(format_key(keys))
+    end
+
+    def format_key(keys)
+      return Array.wrap(keys).join(SEPARATOR)
+    end
+    private :format_key
+  end
+end

data/lib/redis_rds/object.rb

@@ -0,0 +1,74 @@
+module RedisRds
+  class Object
+    attr_accessor :redis_key
+
+    def initialize(redis_key)
+      @redis_key = format_redis_key(redis_key)
+    end
+
+    def self.flushdb
+      connection.flushdb
+    end
+
+    @@namespace = nil
+    @@connection = nil
+    def self.configure(options)
+      @@namespace = options[:namespace]
+      @@connection = options[:connection]
+    end
+
+    def self.connection
+      return @@connection
+    end
+
+    def connection
+      return @@connection
+    end
+
+    def namespace
+      return @@namespace
+    end
+
+    def delete
+      return connection.del(@redis_key)
+    end
+
+    def type
+      return connection.type(@redis_key)
+    end
+
+    def expire(expiry)
+      return connection.expire(@redis_key, expiry)
+    end
+
+    def expireat(timestamp)
+      return connection.expireat(@redis_key, timestamp.to_i)
+    end
+
+    def dump
+      return connection.dump(@redis_key)
+    end
+
+    def exists?
+      return connection.exists(@redis_key)
+    end
+
+    def persist
+      return connection.persist(@redis_key)
+    end
+
+    def ttl
+      return connection.ttl(@redis_key)
+    end
+
+    def pttl
+      return connection.pttl(@redis_key)
+    end
+
+    def format_redis_key(key)
+      key = "#{namespace}:#{key}" unless key.start_with?(namespace)
+      return key
+    end
+    private :format_redis_key
+  end
+end

data/lib/redis_rds/set.rb

@@ -0,0 +1,60 @@
+module RedisRds
+  class Set < RedisRds::Object
+    include Enumerable
+
+    def add(item)
+      return connection.sadd(@redis_key, item)
+    end
+    alias << add
+    alias push add
+
+    def merge(enumerable)
+      lua_script = "
+        local result = 0;
+        for i, item in ipairs(ARGV) do
+          result = result + redis.call('sadd', KEYS[1], item);
+        end
+        return result;"
+      result = connection.eval(lua_script, [@redis_key], enumerable.entries)
+      result = [] if result.blank?
+
+      return result
+    end
+
+    def remove(item)
+      return connection.srem(@redis_key, item)
+    end
+
+    def all
+      return ::Set.new(connection.smembers(@redis_key)).to_a
+    end
+
+    def consume
+      lua_script = "
+        local result = redis.call('smembers', KEYS[1]);
+        redis.call('del', KEYS[1]);
+        return result;"
+      result = connection.eval(lua_script, [@redis_key])
+      result = [] if result.blank?
+
+      return ::Set.new(Array.wrap(result).compact).to_a
+    end
+
+    def size
+      return connection.scard(@redis_key)
+    end
+
+    def include?(object)
+      return connection.sismember(@redis_key, object)
+    end
+
+    def to_json
+      return all.to_json
+    end
+
+    # TODO: Implement lazy enumerator
+    def each(&block)
+      return all.each(&block)
+    end
+  end
+end

data/lib/redis_rds/sorted_set.rb

@@ -0,0 +1,61 @@
+module RedisRds
+  class SortedSet < RedisRds::Object
+    include Enumerable
+
+    def add(score, item)
+      return connection.zadd(@redis_key, score, item)
+    end
+
+    def push(item)
+      index = size
+      return add(index, item)
+    end
+    alias << push
+
+    def all
+      return connection.zrange(@redis_key, 0, -1).to_a
+    end
+
+    def empty?
+      return size == 0
+    end
+
+    def size
+      return connection.zcard(@redis_key)
+    end
+
+    def include?(item)
+      return !index_of(item).nil?
+    end
+
+    def remove(item)
+      return connection.zrem(@redis_key, item)
+    end
+
+    def remove_by_score(min, max)
+      return connection.zremrangebyscore(@redis_key, min, max)
+    end
+
+    def range(min, max, order: :asc)
+      case order
+      when :desc
+        connection.zrevrange(@redis_key, min, max)
+      else
+        connection.zrange(@redis_key, min, max)
+      end
+    end
+
+    def index_of(item)
+      return connection.zrank(@redis_key, item)
+    end
+
+    def to_json
+      return all.to_json
+    end
+
+    # TODO: Implement lazy enumerator
+    def each(&block)
+      return all.each(&block)
+    end
+  end
+end

data/lib/redis_rds/sorted_string_set.rb

@@ -0,0 +1,30 @@
+module RedisRds
+  class SortedStringSet < RedisRds::SortedSet
+    DEFAULT_SCORE = 0
+
+    def add(item)
+      super(DEFAULT_SCORE, item)
+    end
+
+    def push(item)
+      return add(item)
+    end
+
+    def all
+      return range('-', '+').to_a
+    end
+
+    def remove(item)
+      return connection.zrem(@redis_key, item)
+    end
+
+    def range(min, max)
+      min, max = [min, max].map do |r|
+        next(r) if ['-', '+'].include?(r) || r.start_with?('[') || r.start_with?('(')
+        "[#{r}"
+      end
+
+      return connection.zrangebylex(@redis_key, min, max)
+    end
+  end
+end

data/lib/redis_rds/string.rb

@@ -0,0 +1,43 @@
+module RedisRds
+  class String < RedisRds::Object
+    def get
+      return connection.get(@redis_key)
+    end
+
+    def set(value)
+      return connection.set(@redis_key, value)
+    end
+
+    def setex(value, expiry)
+      return connection.setex(@redis_key, expiry, value)
+    end
+
+    def append(suffix)
+      return connection.append(@redis_key, suffix)
+    end
+
+    def incr
+      return connection.incr(@redis_key)
+    end
+
+    def incrby(increment)
+      return connection.incrby(@redis_key, increment)
+    end
+
+    def length
+      return connection.strlen(@redis_key)
+    end
+
+    def setnx(value)
+      return connection.setnx(@redis_key, value)
+    end
+
+    def decr
+      return connection.decr(@redis_key)
+    end
+
+    def decrby(decrement)
+      return connection.decrby(@redis_key, decrement)
+    end
+  end
+end

data/lib/redis_rds/version.rb

@@ -0,0 +1,3 @@
+module RedisRds
+  VERSION = '0.1.1'.freeze
+end

data/lib/redis_rds.rb

@@ -0,0 +1,20 @@
+require 'active_support'
+require 'active_support/core_ext'
+
+require 'redis_rds/version'
+
+require 'redis_rds/config'
+require 'redis_rds/composite'
+require 'redis_rds/object'
+require 'redis_rds/string'
+require 'redis_rds/hash'
+require 'redis_rds/expirable_hash'
+require 'redis_rds/list'
+require 'redis_rds/mutex'
+require 'redis_rds/nested_hash'
+require 'redis_rds/set'
+require 'redis_rds/sorted_set'
+require 'redis_rds/sorted_string_set'
+
+module RedisRds
+end

data/redis_rds.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis_rds/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'redis_rds'
+  spec.version       = RedisRds::VERSION
+  spec.authors       = ['Checkitmobile GmbH']
+  spec.email         = ['support@barcoo.com']
+
+  spec.summary       = 'Ruby data structures stored in Redis.'
+  spec.description   = 'RedisRds provides Ruby interfaces for data structures like String or Hash stored in Redis.'
+  spec.homepage      = 'https://github.com/barcoo/redis_rds'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'redis', '~> 3.2'
+  spec.add_dependency 'activesupport', '~> 4'
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'pry'
+end

data/redis_rds.sublime-project

@@ -0,0 +1,23 @@
+{
+  "folders":
+  [
+    {
+      "path": ".",
+      "folder_exclude_patterns": ["log", "tmp"],
+      "file_exclude_patterns": [".rubocop-*", "*.md-u", "*~"]
+    }
+  ],
+  "settings":
+  {
+    "translate_tabs_to_spaces": true
+  },
+  "SublimeLinter": {
+    "linters": {
+      "rubocop": {
+        "@disable": false,
+        "args": ["--config", "${project}/.rubocop.yml"],
+        "excludes": []
+      }
+    }
+  }
+}

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification
+name: redis_rds
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Checkitmobile GmbH
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RedisRds provides Ruby interfaces for data structures like String or
+  Hash stored in Redis.
+email:
+- support@barcoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- doc/ROADMAP.md
+- lib/redis_rds.rb
+- lib/redis_rds/composite.rb
+- lib/redis_rds/config.rb
+- lib/redis_rds/expirable_hash.rb
+- lib/redis_rds/hash.rb
+- lib/redis_rds/list.rb
+- lib/redis_rds/mutex.rb
+- lib/redis_rds/nested_hash.rb
+- lib/redis_rds/object.rb
+- lib/redis_rds/set.rb
+- lib/redis_rds/sorted_set.rb
+- lib/redis_rds/sorted_string_set.rb
+- lib/redis_rds/string.rb
+- lib/redis_rds/version.rb
+- redis_rds.gemspec
+- redis_rds.sublime-project
+homepage: https://github.com/barcoo/redis_rds
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: Ruby data structures stored in Redis.
+test_files: []