redis-client-extensions 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e12a53c22b3753cbf66fce5f000c1a46978669e
+  data.tar.gz: 90684cb72c11c0bfa4a1cc8e53db489f6489aa00
+SHA512:
+  metadata.gz: f54b97287fdc8df43828e3276f196bd30e76e34263121cf820b6e96d90eb64b795a5b56174bbb7d44ccdc316c3d4cfe019b2e80933f2f7a97a5cfceecbf23a76
+  data.tar.gz: a5f38f645e1be7397ab0e3d8d38027ffb601349d9cf7c8bda0b628679bcc9d038410e1276e3aa0f91256738a38ca0630e43ec84b740b4b6c393645242fc26686

data/.gitignore

@@ -0,0 +1,45 @@
+# Numerous always-ignore extensions
+*.diff
+*.err
+*.orig
+*.log
+*.rej
+*.swo
+*.swp
+*.vi
+*~
+*.sass-cache
+
+# OS or Editor folders
+.DS_Store
+.cache
+.project
+.settings
+.tmproj
+nbproject
+Thumbs.db
+
+# Dreamweaver added files
+_notes
+dwsync.xml
+
+# Komodo
+*.komodoproject
+.komodotools
+
+# Folders to ignore
+.hg
+.svn
+.CVS
+intermediate
+publish
+.idea
+.bundle
+db/*.sqlite3
+log/*.log
+tmp/
+.sass-cache/
+dump.rdb
+*.gem
+Makefile
+

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-version

@@ -0,0 +1 @@
+2.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    redis-client-extensions (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.2.5)
+    mock_redis (0.13.2)
+    redis (3.0.7)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.2)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mock_redis (~> 0.13.2)
+  redis (~> 3.0.7)
+  redis-client-extensions!
+  rspec (~> 3.0.0)

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Andrew Berls
+
+MIT License
+
+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,103 @@
+# RedisClientExtensions
+
+A set of useful core extensions to the [redis-rb](https://github.com/redis/redis-rb) client library, extracted from
+[KnowMyRankings](https://www.knowmyrankings.com/).
+
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'redis-client-extensions'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install redis-client-extensions
+
+
+The extensions will add themselves to the Redis client automatically - in our Rails app, we have
+an initializer that looks something like
+
+```ruby
+require 'redis-client-extensions'
+
+$redis = Redis.new(...)
+```
+
+The extensions also work with [MockRedis](https://github.com/causes/mock_redis) out of the box
+if it is installed.
+
+Note that the library is coded against Ruby 2.1+.
+
+## Usage
+
+Currently added functions are:
+
+- `hmultiset(hkey, hash)` - convenience method for storing a Ruby hash into a redis hash
+
+```ruby
+$redis.hmultiset("my-hash", { name: "tom", color: "red" })
+$redis.hget("my-hash", "name") # => "tom"
+$redis.hget("my-hash", "color") # => "red"
+```
+
+- `find_keys_in_batches(options)` - A wrapper for [SCAN](http://redis.io/commands/scan) to iterate over keys matching a pattern.
+  Options are passed through to SCAN.
+
+```ruby
+$redis.find_keys_in_batches(match: "mypattern*", count: 100) do |keys|
+  puts "Got batch of #{keys.count} keys"
+  puts "Values for this batch: #{$redis.mget(keys)}"
+end
+```
+
+- `get_i(key)` - Parse an Integer stored at a key
+
+```ruby
+$redis.get_i('price') # => 9
+```
+
+- `cache_fetch(key, expires_in:, &block)` - Get or set a value (to be stored with [Marshal](http://www.ruby-doc.org/core-2.1.2/Marshal.html)) expiring in some number of seconds
+
+```ruby
+# Initial cache miss, block evaluated to store value
+ret = $redis.cache_fetch('my-key', expires_in: 60) do
+  'cached-value'
+end
+# => 'cached-value'
+#
+# Calling again retrieves cached value, block will not be called
+ret = $redis.cache_fetch('my-key', expires_in: 60) do
+  'something-else' # Not called!
+end
+# => 'cached-value'
+```
+
+- `mdump(key, val)` - Serialize and store a value at `key` using Marshal
+
+```ruby
+$redis.mdump('my-key', [1,2,3]) # => 'OK'
+```
+
+- `mload(key)` - Retrieve a Marshalled value from `key`
+
+```ruby
+$redis.mdump('my-key', [1,2,3])
+$redis.mload('my-key') # => [1,2,3]
+$redis.mload('does-not-exist') # => nil
+```
+
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/redis-client-extensions/fork )
+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

data/lib/redis-client-extensions.rb

@@ -0,0 +1,106 @@
+require 'redis'
+
+module RedisClientExtensions
+
+  # Store a Ruby hash into a redis hash
+  #
+  # Examples:
+  #   $redis.hmultiset("my-key", { name: "tom", color: "red" })
+  #   $redis.hget("my-key", "name") # => "tom"
+  #   $redis.hget("my-key", "color") # => "red"
+  #
+  # Returns 'OK'
+  def hmultiset(hkey, hash)
+    hmset(hkey, *(hash.map { |k, v| [k, v] }.flatten))
+    'OK'
+  end
+
+
+  # Wrapper for #scan to iterate over a set of keys matching a pattern
+  #
+  # options - Hash of options
+  #   :match - String pattern to match against, ex: "mypattern*"
+  #   :count - (Optional) Integer hint for number of elements to return
+  #     each iteration
+  #
+  # <block> - Proc to handle each batch of keys
+  #   Will be invoked with Array[String] of key names
+  #
+  # Ex:
+  #
+  #   $redis.find_keys_in_batches(match: "mypattern*", count: 100) do |keys|
+  #     puts "Got batch of #{keys.count} keys"
+  #     puts "Values for this batch: #{$redis.mget(keys)}"
+  #   end
+  #
+  # See Redis docs for SCAN.
+  #
+  # Returns nothing
+  def find_keys_in_batches(options={})
+    cursor = 0
+    while (cursor, keys = scan(cursor, options); cursor.to_i != 0)
+      yield keys
+    end
+
+    yield keys # Leftovers from final iteration
+  end
+
+
+  # Parse the value stored at `key` as an Integer,
+  # or return nil if it doesn't exist
+  #
+  # key - String key
+  #
+  # Return Integer or nil
+  def get_i(key)
+    val = get(key)
+    val.nil? ? nil : val.to_i
+  end
+
+
+  # Get/set a value cached in a key
+  # Values are marshalled to preserve class
+  #
+  # key - String key name
+  # expires_in: Integer TTL of the key, in seconds
+  # block - Proc to compute the value to be cached on miss
+  #
+  # Returns cached value or result of evaluating <block>
+  def cache_fetch(key, expires_in:, &block)
+    if ret = mload(key)
+      ret
+    else
+      val = block.call
+      mdump(key, val)
+      expire(key, expires_in)
+      val
+    end
+  end
+
+
+  # Load a Marshalled value stored at <key>
+  # Returns nil if key does not exist
+  #
+  # Returns class of marshalled value
+  def mload(key)
+    if val = get(key)
+      Marshal.load(val)
+    end
+  end
+
+
+  # Store a marshalled value at <key>
+  #
+  # key - String key
+  # val = Any value
+  #
+  # Returns 'OK'
+  def mdump(key, val)
+    set(key, Marshal.dump(val))
+  end
+
+end
+
+
+Redis.send(:include, RedisClientExtensions)
+defined?(MockRedis) and MockRedis.send(:include, RedisClientExtensions)

data/lib/redis-client-extensions/version.rb

@@ -0,0 +1,3 @@
+module RedisClientExtensions
+  VERSION = '0.0.1'
+end

data/redis-client-extensions.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'redis-client-extensions/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "redis-client-extensions"
+  spec.version       = RedisClientExtensions::VERSION
+  spec.authors       = ["Andrew Berls"]
+  spec.email         = ["andrew.berls@gmail.com"]
+  spec.summary       = %q{Useful extensions to the redis-rb client library}
+  spec.description   = %q{A set of core extensions to the redis-rb client library}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'mock_redis', '~> 0.13.2'
+  spec.add_development_dependency 'redis', '~> 3.0.7'
+  spec.add_development_dependency 'rspec', '~> 3.0.0'
+end

data/spec/redis_client_extensions_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe RedisClientExtensions do
+  let(:redis) { MockRedis.new }
+
+  context '#hmultiset' do
+    let(:key) { 'myhash' }
+    let(:hash) do
+      {
+        one: 'a',
+        two: 'b',
+        three: 'c'
+      }
+    end
+
+    it 'sets a redis hash value for each value in the hash' do
+      redis.hmultiset(key, hash)
+
+      expect(redis.hget(key, 'one')).to eq 'a'
+      expect(redis.hget(key, 'two')).to eq 'b'
+      expect(redis.hget(key, 'three')).to eq 'c'
+    end
+  end
+
+
+  context '.get_i' do
+    it 'parses a value as an integer' do
+      redis.set('mykey', 1)
+
+      expect(redis.get_i('mykey')).to eq 1
+    end
+
+    it 'returns nil for nonexistent keys' do
+      expect(redis.get_i('does-not-exist')).to be_nil
+    end
+  end
+
+
+  # No scan in MockRedis. Leaving this test for posterity.
+  #
+  # context '#find_keys_in_batches' do
+  #   before do
+  #     redis.set('test:a', 'one')
+  #     redis.set('test:b', 'two')
+  #     redis.set('test:c', 'three')
+  #     redis.set('test:d', 'four')
+  #   end
+  #
+  #   it 'iterates over each key matching a pattern' do
+  #     result = []
+  #     redis.find_keys_in_batches.each do |keys|
+  #       result.concat(redis.mget(keys))
+  #     end
+  #
+  #     expect(result).to eq ['one', 'two', 'three', 'four']
+  #   end
+  # end
+
+
+  context '#cache_fetch' do
+    let(:key) { "cache-fetch-test" }
+
+    after(:each) { redis.del(key) }
+
+    it 'stores a value into the cache on miss' do
+      expect(redis).to receive(:set).with(key, Marshal.dump('cached-value'))
+                                    .and_return('cached-value')
+      expect(redis).to receive(:expire).with(key, 60)
+
+      redis.cache_fetch(key, expires_in: 60) do
+        'cached-value'
+      end
+    end
+
+    it 'retrieves cached values' do
+      redis.set(key, Marshal.dump('cached-value'))
+      expect(redis).to_not receive(:set)
+      expect(redis).to_not receive(:expire)
+
+      val = redis.cache_fetch(key, expires_in: 300) do
+        'wont_be_called'
+      end
+      expect(val).to eq 'cached-value'
+    end
+  end
+
+
+  context '#mload' do
+    let(:key) { 'mload-test' }
+
+    it 'retrieves a marshalled value' do
+      redis.set(key, Marshal.dump([1,2,3]))
+      expect(redis.mload(key)).to eq [1,2,3]
+    end
+
+    it 'returns nil for keys that do not exist' do
+      expect(redis.mload('does-not-exist')).to be_nil
+    end
+  end
+
+
+  context '#mdump' do
+    let(:key) { 'medump-test' }
+
+    it 'stores a marshalled value' do
+      expect(redis.mdump(key, [1,2,3])).to eq 'OK'
+
+      expect(Marshal.load(redis.get(key))).to eq [1,2,3]
+    end
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mock_redis'
+require 'redis-client-extensions'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: redis-client-extensions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Andrew Berls
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mock_redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.7
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+description: A set of core extensions to the redis-rb client library
+email:
+- andrew.berls@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- lib/redis-client-extensions.rb
+- lib/redis-client-extensions/version.rb
+- redis-client-extensions.gemspec
+- spec/redis_client_extensions_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Useful extensions to the redis-rb client library
+test_files:
+- spec/redis_client_extensions_spec.rb
+- spec/spec_helper.rb