rediska 0.0.2

data/lib/rediska/sorted_set_argument_handler.rb

@@ -0,0 +1,54 @@
+module Rediska
+  class SortedSetArgumentHandler
+    attr_reader :aggregate
+    attr_accessor :number_of_keys, :keys, :weights, :type
+
+    def initialize(args)
+      @number_of_keys = args.shift
+      @keys = args.shift(number_of_keys)
+      args.inject(self) {|handler, item| handler.handle(item) }
+
+      # Defaults.
+      @weights ||= Array.new(number_of_keys) { 1 }
+      @aggregate ||= :sum
+
+      # Validation.
+      raise Redis::CommandError, 'ERR syntax error' unless weights.size == number_of_keys
+      raise Redis::CommandError, 'ERR syntax error' unless [:min, :max, :sum].include?(aggregate)
+    end
+
+    def aggregate=(str)
+      raise Redis::CommandError, 'ERR syntax error' if @aggregate
+
+      @aggregate = str.to_s.downcase.to_sym
+    end
+
+    def handle(item)
+      case item
+      when 'WEIGHTS'
+        @type = :weights
+        @weights = []
+      when 'AGGREGATE'
+        @type = :aggregate
+      when nil
+        raise Redis::CommandError, 'ERR syntax error'
+      else
+        send "handle_#{type}", item
+      end
+
+      self
+    end
+
+    def handle_weights(item)
+      @weights << item
+    end
+
+    def handle_aggregate(item)
+      @aggregate = item
+    end
+
+    def inject_block
+      lambda { |handler, item| handler.handle(item) }
+    end
+  end
+end

data/lib/rediska/sorted_set_store.rb

@@ -0,0 +1,80 @@
+module Rediska
+  class SortedSetStore
+    attr_accessor :data, :weights, :aggregate, :keys
+
+    def initialize(params, data)
+      @data = data
+      @weights = params.weights
+      @aggregate = params.aggregate
+      @keys = params.keys
+    end
+
+    def hashes
+      @hashes ||= keys.map do |src|
+        case data[src]
+        when ::Set
+          Hash[data[src].map {|k,v| [k, 1]}]
+        when Hash
+          data[src]
+        else
+          {}
+        end
+      end
+    end
+
+    def computed_values
+      @computed_values ||= begin
+        # Do nothing if all weights are 1, as n * 1 is n.
+        if weights.all? {|weight| weight == 1 }
+          values = hashes
+        # Otherwise, multiply the values in each hash by that hash's weighting
+        else
+          values = hashes.each_with_index.map do |hash, index|
+            weight = weights[index]
+            Hash[hash.map {|k, v| [k, (v * weight)]}]
+          end
+        end
+      end
+    end
+
+    def aggregate_sum(out)
+      selected_keys.each do |key|
+        out[key] = computed_values.inject(0) do |n, hash|
+          n + (hash[key] || 0)
+        end
+      end
+    end
+
+    def aggregate_min(out)
+      selected_keys.each do |key|
+        out[key] = computed_values.map {|h| h[key] }.compact.min
+      end
+    end
+
+    def aggregate_max(out)
+      selected_keys.each do |key|
+        out[key] = computed_values.map {|h| h[key] }.compact.max
+      end
+    end
+
+    def selected_keys
+      raise NotImplemented, "subclass needs to implement #selected_keys"
+    end
+
+    def call
+      ZSet.new.tap {|out| send("aggregate_#{aggregate}", out) }
+    end
+  end
+
+  class SortedSetIntersectStore < SortedSetStore
+    def selected_keys
+      @values ||= hashes.inject([]) { |r, h| r.empty? ? h.keys : (r & h.keys) }
+    end
+  end
+
+  class SortedSetUnionStore < SortedSetStore
+    def selected_keys
+      @values ||= hashes.map(&:keys).flatten.uniq
+    end
+  end
+end

data/lib/rediska/version.rb

@@ -0,0 +1,3 @@
+module Rediska
+  VERSION = '0.0.2'
+end

data/lib/rediska/zset.rb

@@ -0,0 +1,26 @@
+module Rediska
+  class ZSet < Hash
+    def []=(key, val)
+      super(key, floatify(val))
+    end
+
+    def increment(key, val)
+      self[key] += floatify(val)
+    end
+
+    def select_by_score(min, max)
+      min = floatify(min)
+      max = floatify(max)
+      reject {|_,v| v < min || v > max }
+    end
+
+    private
+    def floatify(str)
+      if inf = str.to_s.match(/^([+-])?inf/i)
+        (inf[1] == '-' ? -1.0 : 1.0) / 0.0
+      else
+        Float(str)
+      end
+    end
+  end
+end

data/lib/rediska.rb

@@ -0,0 +1,18 @@
+require 'redis'
+require 'rediska/configuration'
+require 'rediska/connection'
+
+module Rediska
+  extend self
+
+  attr_accessor :configuration
+
+  def configure
+    Redis::Connection.drivers << Rediska::Connection
+
+    self.configuration ||= Configuration.new
+    yield configuration
+  end
+end
+
+Rediska.configure {}

data/rediska.gemspec

@@ -0,0 +1,26 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'rediska/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'rediska'
+  s.version     = Rediska::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Leonid Beder']
+  s.email       = ['leonid.beder@gmail.com']
+  s.license     = 'MIT'
+  s.homepage    = 'https://github.com/lbeder/rediska'
+  s.summary     = 'A light-weighted redis driver for testing, development, and minimal environments'
+  s.description = 'A light-weighted redis driver for testing, development, and minimal environments,
+    which supports various data storage strategies'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_runtime_dependency     'redis', '~> 3.0.0'
+  s.add_development_dependency 'rspec', '~> 2.14'
+  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-debugger'
+end

data/spec/redis_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+shared_examples 'redis' do
+  it_behaves_like 'compatibility'
+  it_behaves_like 'hashes'
+  it_behaves_like 'connection'
+  it_behaves_like 'keys'
+  it_behaves_like 'lists'
+  it_behaves_like 'server'
+  it_behaves_like 'sets'
+  it_behaves_like 'strings'
+  it_behaves_like 'transactions'
+  it_behaves_like 'sorted sets'
+  it_behaves_like 'upcase method names'
+end
+
+describe 'Rediska' do
+  subject { Redis.new }
+
+  before do
+    Rediska.configure do |config|
+      config.namespace = 'rediska_test'
+    end
+  end
+
+  context 'fake redis' do
+    context 'memory' do
+      before do
+        subject.flushall
+      end
+
+      it_behaves_like 'redis'
+    end
+
+    context 'PStore' do
+      before do
+        Rediska.configure do |config|
+          config.database = :filesystem
+        end
+
+        subject.flushall
+      end
+
+      it_behaves_like 'redis'
+    end
+  end
+
+  # Remove the pending declaration in order to test interoperability with a local instance of redis.
+  pending 'real redis (interoperability)' do
+    before do
+      subject.flushall
+    end
+
+    before(:all) do
+      Redis::Connection.drivers.pop
+    end
+
+    after(:all) do
+      Redis::Connection.drivers << Rediska::Connection
+    end
+
+    it_behaves_like 'redis'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'rubygems'
+require 'coveralls'
+require 'pry'
+require 'pry-debugger'
+require 'rediska'
+
+Coveralls.wear!
+
+Dir['./spec/support/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.order = 'random'
+end

data/spec/support/compatibility.rb

@@ -0,0 +1,7 @@
+shared_examples 'compatibility' do
+  it 'should be accessible through Rediska::Redis' do
+    expect {
+      Rediska::Redis.new
+    }.not_to raise_error
+  end
+end

data/spec/support/connection.rb

@@ -0,0 +1,65 @@
+shared_examples 'connection' do
+  it 'should authenticate to the server' do
+    begin
+      subject.auth('pass').should eq('OK')
+    rescue Redis::CommandError => e
+      raise unless e.message == 'ERR Client sent AUTH, but no password is set'
+    end
+  end
+
+  it 'should re-use the same instance with the same host and port' do
+    subject1 = Redis.new(host: '127.0.0.1', port: 6379)
+    subject2 = Redis.new(host: '127.0.0.1', port: 6379)
+
+    subject1.set('key1', '1')
+    subject2.get('key1').should eq('1')
+
+    subject2.set('key2', '2')
+    subject1.get('key2').should eq('2')
+
+    subject1.get('key3').should be_nil
+    subject2.get('key3').should be_nil
+
+    subject1.dbsize.should eq(2)
+    subject2.dbsize.should eq(2)
+  end
+
+  it 'should connect to a specific database' do
+    subject1 = Redis.new(host: '127.0.0.1', port: 6379, db: 0)
+    subject1.set('key1', '1')
+    subject1.select(0)
+    subject1.get('key1').should eq('1')
+
+    subject2 = Redis.new(host: '127.0.0.1', port: 6379, db: 1)
+    subject2.set('key1', '1')
+    subject2.select(1)
+    subject2.get('key1').should eq('1')
+  end
+
+  it 'should handle multiple clients using the same db instance' do
+    subject1 = Redis.new(host: '127.0.0.1', port: 6379, db: 1)
+    subject2 = Redis.new(host: '127.0.0.1', port: 6379, db: 2)
+
+    subject1.set('key1', 'one')
+    subject1.get('key1').should eq('one')
+
+    subject2.set('key2', 'two')
+    subject2.get('key2').should eq('two')
+
+    subject1.get('key1').should eq('one')
+  end
+
+  it 'should not error with a disconnected client' do
+    subject1 = Redis.new
+    subject1.client.disconnect
+    subject1.get('key1').should be_nil
+  end
+
+  it 'should echo the given string' do
+    subject.echo('something').should eq('something')
+  end
+
+  it 'should ping the server' do
+    subject.ping.should eq('PONG')
+  end
+end

data/spec/support/hashes.rb

@@ -0,0 +1,189 @@
+shared_examples 'hashes' do
+  it 'should delete a hash field' do
+    subject.hset('key1', 'k1', 'val1')
+    subject.hset('key1', 'k2', 'val2')
+    subject.hdel('key1', 'k1')
+
+    subject.hget('key1', 'k1').should be_nil
+    subject.hget('key1', 'k2').should eq('val2')
+  end
+
+  it 'should remove a hash with no keys left' do
+    subject.hset('key1', 'k1', 'val1')
+    subject.hset('key1', 'k2', 'val2')
+    subject.hdel('key1', 'k1')
+    subject.hdel('key1', 'k2')
+
+    subject.exists('key1').should be_false
+  end
+
+  it 'should convert key to a string for hset' do
+    m = double('key')
+    m.stub(:to_s).and_return('foo')
+
+    subject.hset('key1', m, 'bar')
+    subject.hget('key1', 'foo').should eq('bar')
+  end
+
+  it 'should convert key to a string for hget' do
+    m = double('key')
+    m.stub(:to_s).and_return('foo')
+
+    subject.hset('key1', 'foo', 'bar')
+    subject.hget('key1', m).should eq('bar')
+  end
+
+  it 'should determine if a hash field exists' do
+    subject.hset('key1', 'index', 'value')
+
+    subject.hexists('key1', 'index').should be_true
+    subject.hexists('key2', 'i2').should be_false
+  end
+
+  it 'should get the value of a hash field' do
+    subject.hset('key1', 'index', 'value')
+
+    subject.hget('key1', 'index').should eq('value')
+  end
+
+  it 'should get all the fields and values in a hash' do
+    subject.hset('key1', 'i1', 'val1')
+    subject.hset('key1', 'i2', 'val2')
+
+    subject.hgetall('key1').should eq({'i1' => 'val1', 'i2' => 'val2'})
+  end
+
+  it 'should increment the integer value of a hash field by the given number' do
+    subject.hset('key1', 'cont1', '5')
+    subject.hincrby('key1', 'cont1', '5').should eq(10)
+    subject.hget('key1', 'cont1').should eq('10')
+  end
+
+  it 'should increment non existing hash keys' do
+    subject.hget('key1', 'cont2').should be_nil
+    subject.hincrby('key1', 'cont2', '5').should eq(5)
+  end
+
+  it 'should get all the fields in a hash' do
+    subject.hset('key1', 'i1', 'val1')
+    subject.hset('key1', 'i2', 'val2')
+
+    subject.hkeys('key1').should eq(['i1', 'i2'])
+    subject.hkeys('key2').should be_empty
+  end
+
+  it 'should get the number of fields in a hash' do
+    subject.hset('key1', 'i1', 'val1')
+    subject.hset('key1', 'i2', 'val2')
+
+    subject.hlen('key1').should eq(2)
+  end
+
+  it 'should get the values of all the given hash fields' do
+    subject.hset('key1', 'i1', 'val1')
+    subject.hset('key1', 'i2', 'val2')
+
+    subject.hmget('key1', 'i1', 'i2', 'i3').should eq(['val1', 'val2', nil])
+    subject.hmget('key2', 'i1', 'i2').should eq([nil, nil])
+  end
+
+  it 'should throw an argument error when you do not ask for any keys' do
+    expect {
+      subject.hmget('key1')
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should reject an empty list of values' do
+    expect {
+      subject.hmset('key')
+    }.to raise_error(Redis::CommandError)
+
+    subject.exists('key').should be_false
+  end
+
+  it 'rejects an insert with a key but no value' do
+    expect {
+      subject.hmset('key', 'foo')
+    }.to raise_error(Redis::CommandError)
+
+    expect {
+      subject.hmset('key', 'foo', 3, 'bar')
+    }.to raise_error(Redis::CommandError)
+
+    subject.exists('key').should be_false
+  end
+
+  it 'should reject the wrong number of arguments' do
+    expect {
+      subject.hmset('hash', 'foo1', 'bar1', 'foo2', 'bar2', 'foo3')
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should set multiple hash fields to multiple values' do
+    subject.hmset('key', 'k1', 'value1', 'k2', 'value2')
+
+    subject.hget('key', 'k1').should eq('value1')
+    subject.hget('key', 'k2').should eq('value2')
+  end
+
+  it 'should set multiple hash fields from a ruby hash to multiple values' do
+    subject.mapped_hmset('foo', k1: 'value1', k2: 'value2')
+
+    subject.hget('foo', 'k1').should eq('value1')
+    subject.hget('foo', 'k2').should eq('value2')
+  end
+
+  it 'should set the string value of a hash field' do
+    subject.hset('key1', 'k1', 'val1').should be_true
+    subject.hset('key1', 'k1', 'val1').should be_false
+
+    subject.hget('key1', 'k1').should eq('val1')
+  end
+
+  it 'should set the value of a hash field, only if the field does not exist' do
+    subject.hset('key1', 'k1', 'val1')
+    subject.hsetnx('key1', 'k1', 'value').should be_false
+    subject.hsetnx('key1', 'k2', 'val2').should be_true
+    subject.hsetnx('key1', :k1, 'value').should be_false
+    subject.hsetnx('key1', :k3, 'val3').should be_true
+
+    subject.hget('key1', 'k1').should eq('val1')
+    subject.hget('key1', 'k2').should eq('val2')
+    subject.hget('key1', 'k3').should eq('val3')
+  end
+
+  it 'should get all the values in a hash' do
+    subject.hset('key1', 'k1', 'val1')
+    subject.hset('key1', 'k2', 'val2')
+
+    subject.hvals('key1').should eq(['val1', 'val2'])
+  end
+
+  it 'should accept a list of array pairs as arguments and not throw an invalid argument number error' do
+    subject.hmset('key1', [:k1, 'val1'], [:k2, 'val2'], [:k3, 'val3'])
+    subject.hget('key1', :k1).should eq('val1')
+    subject.hget('key1', :k2).should eq('val2')
+    subject.hget('key1', :k3).should eq('val3')
+  end
+
+  it 'should reject a list of arrays that contain an invalid number of arguments' do
+    expect {
+      subject.hmset('key1', [:k1, 'val1'], [:k2, 'val2', 'bogus val'])
+    }.to raise_error(Redis::CommandError)
+  end
+
+  it 'should convert a integer field name to string for hdel' do
+    subject.hset('key1', '1', 1)
+    subject.hdel('key1', 1).should eq(1)
+  end
+
+  it 'should convert a integer field name to string for hexists' do
+    subject.hset('key1', '1', 1)
+    subject.hexists('key1', 1).should be_true
+  end
+
+  it 'should convert a integer field name to string for hincrby' do
+    subject.hset('key1', 1, 0)
+    subject.hincrby('key1', 1, 1).should eq(1)
+  end
+end