fakeredis 0.1.4 → 0.2.0

data/lib/fakeredis/lists.rb

@@ -1,108 +0,0 @@
-module FakeRedis
-  class Redis
-    module ListsMethods
-
-      def lindex(key, index)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        return unless @data[key]
-        @data[key][index]
-      end
-
-      def linsert(key, where, pivot, value)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        return unless @data[key]
-        index = @data[key].index(pivot)
-        case where
-          when :before then @data[key].insert(index, value)
-          when :after  then @data[key].insert(index + 1, value)
-          else raise ArgumentError.new
-        end
-      end
-
-      def llen(key)
-        @data[key] ||= []
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key].size
-      end
-
-      def lpop(key)
-        return unless @data[key]
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key].delete_at(0)
-      end
-
-      def lpush(key, value)
-        @data[key] ||= []
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key] = [value] + @data[key]
-        @data[key].size
-      end
-
-      def lpushx(key, value)
-        return unless @data[key]
-        fail "Not a list" unless @data[key].is_a?(Array)
-        lpush(key, value)
-      end
-
-      def lrange(key, startidx, endidx)
-        return unless @data[key]
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key][startidx..endidx]
-      end
-
-      def lrem(key, count, value)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        return unless @data[key]
-        old_size = @data[key].size
-        if count == 0
-          @data[key].delete(value)
-          old_size - @data[key].size
-        else
-          array = count > 0 ? @data[key].dup : @data[key].reverse
-          count.abs.times{ array.delete_at(array.index(value) || array.length) }
-          @data[key] = count > 0 ? array.dup : array.reverse
-          old_size - @data[key].size
-        end
-      end
-
-      def lset(key, index, value)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        return unless @data[key]
-        raise RuntimeError unless index < @data[key].size
-        @data[key][index] = value
-      end
-
-      def ltrim(key, start, stop)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        return unless @data[key]
-        @data[key] = @data[key][start..stop]
-      end
-
-      def rpop(key)
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key].pop
-      end
-
-      def rpoplpush(key1, key2)
-        fail "Not a list" unless @data[key1].is_a?(Array)
-        elem = @data[key1].pop
-        lpush(key2, elem)
-      end
-
-      def rpush(key, value)
-        @data[key] ||= []
-        fail "Not a list" unless @data[key].is_a?(Array)
-        @data[key].push(value)
-      end
-
-      def rpushx(key, value)
-        return unless @data[key]
-        fail "Not a list" unless @data[key].is_a?(Array)
-        rpush(key, value)
-      end
-
-    end
-
-    include ListsMethods
-  end
-end

data/lib/fakeredis/server.rb

@@ -1,65 +0,0 @@
-module FakeRedis
-  class Redis
-    module ServerMethods
-
-      def bgreriteaof ; end
-
-      def bgsave ; end
-
-      def config_get(param) ; end
-
-      def config_set(param, value) ; end
-
-      def config_resetstat ; end
-
-      def dbsize
-        @data.keys.count
-      end
-
-      def debug_object(key)
-        return @data[key].inspect
-      end
-
-      def flushdb
-        @data = {}
-        @expires = {}
-      end
-
-      alias flushall flushdb
-
-      def info
-        server_info = {
-          "redis_version" => "0.07",
-          "connected_clients" => "1",
-          "connected_slaves" => "0",
-          "used_memory" => "3187",
-          "changes_since_last_save" => "0",
-          "last_save_time" => "1237655729",
-          "total_connections_received" => "1",
-          "total_commands_processed" => "1",
-          "uptime_in_seconds" => "36000",
-          "uptime_in_days" => 0
-        }
-        return server_info
-      end
-
-      def lastsave
-        Time.now.to_i
-      end
-
-      def monitor ; end
-
-      def save ; end
-
-      def shutdown ; end
-
-      def slaveof(host, port) ; end
-
-      def sync ; end
-
-      alias reset flushdb
-    end
-
-    include ServerMethods
-  end
-end

data/lib/fakeredis/sets.rb

@@ -1,122 +0,0 @@
-module FakeRedis
-  class Redis
-    module SetsMethods
-      def sadd(key, value)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then @data[key] = Set.new([value.to_s])
-          when Set then set.add(value.to_s)
-        end
-      end
-
-      def scard(key)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then 0
-          when Set then set.size
-        end
-      end
-
-      def sdiff(key1, *keys)
-        [key1, *keys].each { |k| fail_unless_set(k) }
-        keys = keys.map { |k| @data[k] || Set.new }
-        keys.inject(@data[key1]) do |memo, set|
-          memo - set
-        end.to_a
-      end
-
-      def sdiffstore(destination, key1, *keys)
-        fail_unless_set(destination)
-        result = sdiff(key1, *keys)
-        @data[destination] = Set.new(result)
-      end
-
-      def sinter(*keys)
-        keys.each { |k| fail_unless_set(k) }
-        return Set.new if keys.any? { |k| @data[k].nil? }
-        keys = keys.map { |k| @data[k] || Set.new }
-        keys.inject do |set, key|
-          set & key
-        end.to_a
-      end
-
-      def sinterstore(destination, *keys)
-        fail_unless_set(destination)
-        result = sinter(*keys)
-        @data[destination] = Set.new(result)
-      end
-
-      def sismember(key, value)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then false
-          when Set then set.include?(value.to_s)
-        end
-      end
-
-      def smembers(key)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then []
-          when Set then set.to_a.reverse
-        end
-      end
-
-      def smove(source, destination, value)
-        fail_unless_set(destination)
-        if elem = self.srem(source, value)
-          self.sadd(destination, value)
-        end
-      end
-
-      def spop(key)
-        fail_unless_set(key)
-        elem = srandmember(key)
-        srem(key, elem)
-        elem
-      end
-
-      def srandmember(key)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then nil
-          when Set then set.to_a[rand(set.size)]
-        end
-      end
-
-      def srem(key, value)
-        fail_unless_set(key)
-        case set = @data[key]
-          when nil then return
-          when Set then set.delete(value.to_s)
-        end
-      end
-
-      def sunion(*keys)
-        keys.each { |k| fail_unless_set(k) }
-        keys = keys.map { |k| @data[k] || Set.new }
-        keys.inject(Set.new) do |set, key|
-          set | key
-        end.to_a
-      end
-
-      def sunionstore(destination, *keys)
-        fail_unless_set(destination)
-        result = sunion(*keys)
-        @data[destination] = Set.new(result)
-      end
-
-      private
-
-      def is_a_set?(key)
-        @data[key].is_a?(Set) || @data[key].nil?
-      end
-
-      def fail_unless_set(key)
-        fail "Not a set" unless is_a_set?(key)
-      end
-    end
-
-    include SetsMethods
-  end
-end

data/lib/fakeredis/sorted_sets.rb

@@ -1,108 +0,0 @@
-module FakeRedis
-  class Redis
-    module SortedSetsMethods
-      class Elem < String
-        attr_accessor :score
-        def initialize(str="", score)
-          super(str)
-          @score = score
-        end
-        def <=>(other)
-          @score <=> other.score
-        end
-      end
-
-      class CustomSortedSet < SortedSet
-        attr_accessor :indexed_set
-        def add(o)
-          super(o)
-          @indexed_set ||= Set.new
-          @indexed_set.add(o)
-        end
-
-        def delete(o)
-          super(o)
-          @indexed_set ||= Set.new
-          @indexed_set.delete(o)
-        end
-      end
-
-      def zadd(key, score, value)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then @data[key] = CustomSortedSet.new([Elem.new(value.to_s, score)])
-          when CustomSortedSet then set.delete(value.to_s) ; set.add(Elem.new(value.to_s, score))
-        end
-      end
-
-      def zcard(key)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then 0
-          when CustomSortedSet then set.size
-        end
-      end
-
-      def zcount(key, min, max)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then 0
-          when CustomSortedSet then set.select{|x| x.score >= min && x.score <= max }.size
-        end
-      end
-
-      def zincrby(key, incr, value)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then @data[key] = CustomSortedSet.new([Elem.new(value.to_s, incr)])
-          when CustomSortedSet then 
-            score = set.to_a.select{|x| x == value.to_s}.first.score
-            set.delete(value.to_s)
-            set.add(Elem.new(value.to_s, score+incr))
-        end
-      end
-
-      def zrange(key, start, stop)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then []
-          when CustomSortedSet then set.indexed_set.to_a[start..stop]
-        end
-      end
-
-      def zrangescore(key, start, stop)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then []
-          when CustomSortedSet then set.to_a.reverse[start..stop]
-        end
-      end
-
-      def zrank(key, value)
-        fail_unless_sorted_set(key)
-        case set = @data[key]
-          when nil then nil
-          when CustomSortedSet then set.to_a.index(value)
-        end
-      end
-
-      def zscore(key, value)
-        case set = @data[key]
-          when nil then 0
-          when CustomSortedSet then set.to_a.select{|x| x == value.to_s}.first.score
-        end
-      end
-
-      private
-
-      def is_a_sorted_set?(key)
-        @data[key].is_a?(CustomSortedSet) || @data[key].nil?
-      end
-
-      def fail_unless_sorted_set(key)
-        fail "Not a sorted set" unless is_a_sorted_set?(key)
-      end
-    end
-    include SortedSetsMethods
-  end
-end

data/lib/fakeredis/strings.rb

@@ -1,116 +0,0 @@
-module FakeRedis
-  class Redis
-    module StringsMethods
-
-      def append(key, value)
-        @data[key] = (@data[key] || "")
-        @data[key] = @data[key] + value.to_s
-      end
-
-      def decr(key)
-        @data[key] = (@data[key] || "0")
-        @data[key] = (@data[key].to_i - 1).to_s
-      end
-
-      def decrby(key, by)
-        @data[key] = (@data[key] || "0")
-        @data[key] = (@data[key].to_i - by.to_i).to_s
-      end
-
-      def get(key)
-        #return if expired?(key)
-        @data[key]
-      end
-
-      def getbit(key, offset)
-        #return if expired?(key)
-        return unless @data[key]
-        @data[key].unpack('B8')[0].split("")[offset]
-      end
-
-      def getrange(key, start, ending)
-        return unless @data[key]
-        @data[key][start..ending]
-      end
-
-      def getset(key, value)
-        old_value = @data[key]
-        @data[key] = value
-        return old_value
-      end
-
-      def incr(key)
-        @data[key] = (@data[key] || "0")
-        @data[key] = (@data[key].to_i + 1).to_s
-      end
-
-      def incrby(key, by)
-        @data[key] = (@data[key] || "0")
-        @data[key] = (@data[key].to_i + by.to_i).to_s
-      end
-
-      def mget(*keys)
-        @data.values_at(*keys)
-      end
-
-      def mapped_mget(*keys)
-        reply = mget(*keys)
-        Hash[*keys.zip(reply).flatten]
-      end
-
-      def mset(*pairs)
-        pairs.each_slice(2) do |pair|
-          @data[pair[0].to_s] = pair[1].to_s
-        end
-        "OK"
-      end
-
-      def msetnx(*pairs)
-        keys = []
-        pairs.each_with_index{|item, index| keys << item.to_s if index % 2 == 0}
-        return if keys.any?{|key| @data.key?(key) }
-        mset(*pairs)
-        true
-      end
-
-      def set(key, value)
-        @data[key] = value.to_s
-        "OK"
-      end
-
-      def setbit(key, offset, bit)
-        return unless @data[key]
-        old_val = @data[key].unpack('B*')[0].split("")
-        old_val[offset] = bit.to_s
-        new_val = ""
-        old_val.each_slice(8){|b| new_val = new_val + b.join("").to_i(2).chr }
-        @data[key] = new_val
-      end
-
-      def setex(key, seconds, value)
-        @data[key] = value
-        expire(key, seconds)
-      end
-
-      def setnx(key, value)
-        set(key, value) unless @data.key?(key)
-      end
-
-      def setrange(key, offset, value)
-        return unless @data[key]
-        s = @data[key][offset,value.size]
-        @data[key][s] = value
-      end
-
-      def strlen(key)
-        return unless @data[key]
-        @data[key].size
-      end
-
-      alias [] get
-      alias []= set
-    end
-
-    include StringsMethods
-  end
-end