redis_migrator 0.0.1 → 0.1.1

data/spec/mock_redis/lib/mock_redis/exceptions.rb

@@ -1,3 +0,0 @@
-class MockRedis
-  WouldBlock = Class.new(StandardError)
-end

data/spec/mock_redis/lib/mock_redis/expire_wrapper.rb

@@ -1,25 +0,0 @@
-require 'mock_redis/undef_redis_methods'
-
-class MockRedis
-  class ExpireWrapper
-    include UndefRedisMethods
-
-    def respond_to?(method, include_private=false)
-      super || @db.respond_to?(method)
-    end
-
-    def initialize(db)
-      @db = db
-    end
-
-    def method_missing(method, *args)
-      @db.expire_keys
-      @db.send(method, *args)
-    end
-
-    def initialize_copy(source)
-      super
-      @db = @db.clone
-    end
-  end
-end

data/spec/mock_redis/lib/mock_redis/hash_methods.rb

@@ -1,118 +0,0 @@
-require 'mock_redis/assertions'
-require 'mock_redis/utility_methods'
-
-class MockRedis
-  module HashMethods
-    include Assertions
-    include UtilityMethods
-
-    def hdel(key, field)
-      with_hash_at(key) do |hash|
-        hash.delete(field.to_s) ? 1 : 0
-      end
-    end
-
-    def hexists(key, field)
-      with_hash_at(key) {|h| h.has_key?(field.to_s)}
-    end
-
-    def hget(key, field)
-      with_hash_at(key) {|h| h[field.to_s]}
-    end
-
-    def hgetall(key)
-      with_hash_at(key) {|h| h}
-    end
-
-    def hincrby(key, field, increment)
-      with_hash_at(key) do |hash|
-        field = field.to_s
-        unless can_incr?(data[key][field])
-          raise RuntimeError, "ERR hash value is not an integer"
-        end
-        unless looks_like_integer?(increment.to_s)
-          raise RuntimeError, "ERR value is not an integer or out of range"
-        end
-
-        new_value = (hash[field] || "0").to_i + increment.to_i
-        hash[field] = new_value.to_s
-        new_value
-      end
-    end
-
-    def hkeys(key)
-      with_hash_at(key, &:keys)
-    end
-
-    def hlen(key)
-      hkeys(key).length
-    end
-
-    def hmget(key, *fields)
-      assert_has_args(fields, 'hmget')
-      fields.map{|f| hget(key, f)}
-    end
-
-    def mapped_hmget(key, *fields)
-      reply = hmget(key, *fields)
-      Hash[*fields.zip(reply).flatten]
-    end
-
-    def hmset(key, *kvpairs)
-      assert_has_args(kvpairs, 'hmset')
-      if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for HMSET"
-      end
-
-      kvpairs.each_slice(2) do |(k,v)|
-        hset(key, k, v)
-      end
-      'OK'
-    end
-
-    def mapped_hmset(key, hash)
-      kvpairs = hash.to_a.flatten
-      assert_has_args(kvpairs, 'hmset')
-      if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for 'hmset' command"
-      end
-
-      hmset(key, *kvpairs)
-    end
-
-    def hset(key, field, value)
-      with_hash_at(key) {|h| h[field.to_s] = value.to_s}
-      true
-    end
-
-    def hsetnx(key, field, value)
-      if hget(key, field)
-        false
-      else
-        hset(key, field, value)
-        true
-      end
-    end
-
-    def hvals(key)
-      with_hash_at(key, &:values)
-    end
-
-    private
-
-    def with_hash_at(key, &blk)
-      with_thing_at(key, :assert_hashy, proc {{}}, &blk)
-    end
-
-    def hashy?(key)
-      data[key].nil? || data[key].kind_of?(Hash)
-    end
-
-    def assert_hashy(key)
-      unless hashy?(key)
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
-      end
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/list_methods.rb

@@ -1,187 +0,0 @@
-require 'mock_redis/assertions'
-require 'mock_redis/utility_methods'
-
-class MockRedis
-  module ListMethods
-    include Assertions
-    include UtilityMethods
-
-    def blpop(*args)
-      lists, timeout = extract_timeout(args)
-      nonempty_list = first_nonempty_list(lists)
-
-      if nonempty_list
-        [nonempty_list, lpop(nonempty_list)]
-      elsif timeout > 0
-        nil
-      else
-        raise MockRedis::WouldBlock, "Can't block forever"
-      end
-    end
-
-    def brpop(*args)
-      lists, timeout = extract_timeout(args)
-      nonempty_list = first_nonempty_list(lists)
-
-      if nonempty_list
-        [nonempty_list, rpop(nonempty_list)]
-      elsif timeout > 0
-        nil
-      else
-        raise MockRedis::WouldBlock, "Can't block forever"
-      end
-    end
-
-    def brpoplpush(source, destination, timeout)
-      assert_valid_timeout(timeout)
-
-      if llen(source) > 0
-        rpoplpush(source, destination)
-      elsif timeout > 0
-        nil
-      else
-        raise MockRedis::WouldBlock, "Can't block forever"
-      end
-    end
-
-    def lindex(key, index)
-      with_list_at(key) {|l| l[index]}
-    end
-
-    def linsert(key, position, pivot, value)
-      unless %w[before after].include?(position.to_s)
-        raise RuntimeError, "ERR syntax error"
-      end
-
-      assert_listy(key)
-      return 0 unless data[key]
-
-      pivot_position = (0..llen(key) - 1).find do |i|
-        data[key][i] == pivot.to_s
-      end
-
-      return -1 unless pivot_position
-
-      insertion_index = if position.to_s == 'before'
-                          pivot_position
-                        else
-                          pivot_position + 1
-                        end
-
-      data[key].insert(insertion_index, value.to_s)
-      llen(key)
-    end
-
-    def llen(key)
-      with_list_at(key, &:length)
-    end
-
-    def lpop(key)
-      with_list_at(key, &:shift)
-    end
-
-    def lpush(key, value)
-      with_list_at(key) {|l| l.unshift(value.to_s)}
-      llen(key)
-    end
-
-    def lpushx(key, value)
-      assert_listy(key)
-      return 0 unless list_at?(key)
-      lpush(key, value)
-    end
-
-    def lrange(key, start, stop)
-      with_list_at(key) {|l| l[start..stop]}
-    end
-
-    def lrem(key, count, value)
-      count = count.to_i
-      value = value.to_s
-
-      with_list_at(key) do |list|
-        indices_with_value = (0..(llen(key) - 1)).find_all do |i|
-          list[i] == value
-        end
-
-        indices_to_delete = if count == 0
-                              indices_with_value.reverse
-                            elsif count > 0
-                              indices_with_value.take(count).reverse
-                            else
-                              indices_with_value.reverse.take(-count)
-                            end
-
-        indices_to_delete.each {|i| list.delete_at(i)}.length
-      end
-    end
-
-    def lset(key, index, value)
-      assert_listy(key)
-
-      unless list_at?(key)
-        raise RuntimeError, "ERR no such key"
-      end
-
-      unless (0...llen(key)).include?(index)
-        raise RuntimeError, "ERR index out of range"
-      end
-
-      data[key][index] = value.to_s
-      'OK'
-    end
-
-    def ltrim(key, start, stop)
-      with_list_at(key) do |list|
-        list.replace(list[start..stop] || []) if list
-        'OK'
-      end
-    end
-
-    def rpop(key)
-      with_list_at(key) {|list| list.pop if list}
-    end
-
-    def rpoplpush(source, destination)
-      value = rpop(source)
-      lpush(destination, value)
-      value
-    end
-
-    def rpush(key, value)
-      with_list_at(key) {|l| l.push(value.to_s)}
-      llen(key)
-    end
-
-    def rpushx(key, value)
-      assert_listy(key)
-      return 0 unless list_at?(key)
-      rpush(key, value)
-    end
-
-    private
-    def list_at?(key)
-      data[key] && listy?(key)
-    end
-
-    def with_list_at(key, &blk)
-      with_thing_at(key, :assert_listy, proc {[]}, &blk)
-    end
-
-    def listy?(key)
-      data[key].nil? || data[key].kind_of?(Array)
-    end
-
-    def assert_listy(key)
-      unless listy?(key)
-        # Not the most helpful error, but it's what redis-rb barfs up
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
-      end
-    end
-
-    def first_nonempty_list(keys)
-      keys.find{|k| llen(k) > 0}
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/multi_db_wrapper.rb

@@ -1,86 +0,0 @@
-require 'mock_redis/undef_redis_methods'
-
-class MockRedis
-  class MultiDbWrapper
-    include UndefRedisMethods
-
-    def initialize(db)
-      @db_index = 0
-
-      @prototype_db = db.clone
-
-      @databases = Hash.new {|h,k| h[k] = @prototype_db.clone}
-      @databases[@db_index] = db
-    end
-
-    def respond_to?(method, include_private=false)
-      super || current_db.respond_to?(method, include_private)
-    end
-
-    def method_missing(method, *args)
-      current_db.send(method, *args)
-    end
-
-    def initialize_copy(source)
-      super
-      @databases = @databases.clone
-      @databases.keys.each do |k|
-        @databases[k] = @databases[k].clone
-      end
-    end
-
-    # Redis commands
-    def flushall
-      @databases.values.each(&:flushdb)
-      'OK'
-    end
-
-    def move(key, db_index)
-      src = current_db
-      dest = db(db_index)
-
-      if !src.exists(key) || dest.exists(key)
-        false
-      else
-        case current_db.type(key)
-        when 'hash'
-          dest.hmset(key, *(src.hgetall(key).map{|k,v| [k,v]}.flatten))
-        when 'list'
-          while value = src.rpop(key)
-            dest.lpush(key, value)
-          end
-        when 'set'
-          while value = src.spop(key)
-            dest.sadd(key, value)
-          end
-        when 'string'
-          dest.set(key, src.get(key))
-        when 'zset'
-          src.zrange(key, 0, -1, :with_scores => true).each_slice(2) do |(m,s)|
-            dest.zadd(key, s, m)
-          end
-        else
-          raise ArgumentError,
-          "Can't move a key of type #{current_db.type(key).inspect}"
-        end
-
-        src.del(key)
-        true
-      end
-    end
-
-    def select(db_index)
-      @db_index = db_index.to_i
-      'OK'
-    end
-
-    private
-    def current_db
-      @databases[@db_index]
-    end
-
-    def db(index)
-      @databases[index]
-    end
-  end
-end

data/spec/mock_redis/lib/mock_redis/set_methods.rb

@@ -1,126 +0,0 @@
-require 'mock_redis/assertions'
-require 'mock_redis/utility_methods'
-
-class MockRedis
-  module SetMethods
-    include Assertions
-    include UtilityMethods
-
-    def sadd(key, member)
-      with_set_at(key) {|s| !!s.add?(member.to_s)}
-    end
-
-    def scard(key)
-      with_set_at(key) {|s| s.length}
-    end
-
-    def sdiff(*keys)
-      assert_has_args(keys, 'sdiff')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:-)}.to_a
-    end
-
-    def sdiffstore(destination, *keys)
-      assert_has_args(keys, 'sdiffstore')
-      with_set_at(destination) do |set|
-        set.replace(sdiff(*keys))
-      end
-      scard(destination)
-    end
-
-    def sinter(*keys)
-      assert_has_args(keys, 'sinter')
-
-      with_sets_at(*keys) do |*sets|
-        sets.reduce(&:&).to_a
-      end
-    end
-
-    def sinterstore(destination, *keys)
-      assert_has_args(keys, 'sinterstore')
-      with_set_at(destination) do |set|
-        set.replace(sinter(*keys))
-      end
-      scard(destination)
-    end
-
-    def sismember(key, member)
-      with_set_at(key) {|s| s.include?(member.to_s)}
-    end
-
-    def smembers(key)
-      with_set_at(key, &:to_a)
-    end
-
-    def smove(src, dest, member)
-      member = member.to_s
-
-      with_sets_at(src, dest) do |src_set, dest_set|
-        if src_set.delete?(member)
-          dest_set.add(member)
-          true
-        else
-          false
-        end
-      end
-    end
-
-    def spop(key)
-      with_set_at(key) do |set|
-        member = set.first
-        set.delete(member)
-        member
-      end
-    end
-
-    def srandmember(key)
-      members = with_set_at(key, &:to_a)
-      members[rand(members.length)]
-    end
-
-    def srem(key, member)
-      with_set_at(key) {|s| !!s.delete?(member.to_s)}
-    end
-
-    def sunion(*keys)
-      assert_has_args(keys, 'sunion')
-      with_sets_at(*keys) {|*sets| sets.reduce(&:+).to_a}
-    end
-
-    def sunionstore(destination, *keys)
-      assert_has_args(keys, 'sunionstore')
-      with_set_at(destination) do |dest_set|
-        dest_set.replace(sunion(*keys))
-      end
-      scard(destination)
-    end
-
-    private
-    def with_set_at(key, &blk)
-      with_thing_at(key, :assert_sety, proc {Set.new}, &blk)
-    end
-
-    def with_sets_at(*keys, &blk)
-      if keys.length == 1
-        with_set_at(keys.first, &blk)
-      else
-        with_set_at(keys.first) do |set|
-          with_sets_at(*(keys[1..-1])) do |*sets|
-            blk.call(*([set] + sets))
-          end
-        end
-      end
-    end
-
-    def sety?(key)
-      data[key].nil? || data[key].kind_of?(Set)
-    end
-
-    def assert_sety(key)
-      unless sety?(key)
-        # Not the most helpful error, but it's what redis-rb barfs up
-        raise RuntimeError, "ERR Operation against a key holding the wrong kind of value"
-      end
-    end
-
-  end
-end