redis_migrator 0.0.1 → 0.1.1

data/spec/mock_redis/lib/mock_redis/string_methods.rb

@@ -1,203 +0,0 @@
-require 'mock_redis/assertions'
-
-class MockRedis
-  module StringMethods
-    include Assertions
-
-    def append(key, value)
-      assert_stringy(key)
-      data[key] ||= ""
-      data[key] << value
-      data[key].length
-    end
-
-    def decr(key)
-      decrby(key, 1)
-    end
-
-    def decrby(key, n)
-      incrby(key, -n)
-    end
-
-    def get(key)
-      assert_stringy(key)
-      data[key]
-    end
-
-    def [](key)
-      get(key)
-    end
-
-    def getbit(key, offset)
-      assert_stringy(key)
-
-      offset_of_byte = offset / 8
-      offset_within_byte = offset % 8
-
-      # String#getbyte would be lovely, but it's not in 1.8.7.
-      byte = (data[key] || "").each_byte.drop(offset_of_byte).first
-
-      if byte
-        (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0
-      else
-        0
-      end
-    end
-
-    def getrange(key, start, stop)
-      assert_stringy(key)
-      (data[key] || "")[start..stop]
-    end
-
-    def getset(key, value)
-      retval = get(key)
-      set(key, value)
-      retval
-    end
-
-    def incr(key)
-      incrby(key, 1)
-    end
-
-    def incrby(key, n)
-      assert_stringy(key)
-      unless can_incr?(data[key])
-        raise RuntimeError, "ERR value is not an integer or out of range"
-      end
-
-      unless looks_like_integer?(n.to_s)
-        raise RuntimeError, "ERR value is not an integer or out of range"
-      end
-
-      new_value = data[key].to_i + n.to_i
-      data[key] = new_value.to_s
-      # for some reason, redis-rb doesn't return this as a string.
-      new_value
-    end
-
-    def mget(*keys)
-      assert_has_args(keys, 'mget')
-
-      keys.map do |key|
-        get(key) if stringy?(key)
-      end
-    end
-
-    def mset(*kvpairs)
-      assert_has_args(kvpairs, 'mset')
-      if kvpairs.length.odd?
-        raise RuntimeError, "ERR wrong number of arguments for MSET"
-      end
-
-      kvpairs.each_slice(2) do |(k,v)|
-        set(k,v)
-      end
-
-      "OK"
-    end
-
-    def msetnx(*kvpairs)
-      assert_has_args(kvpairs, 'msetnx')
-
-      if kvpairs.each_slice(2).any? {|(k,v)| exists(k)}
-        0
-      else
-        mset(*kvpairs)
-        1
-      end
-    end
-
-    def set(key, value)
-      data[key] = value.to_s
-      'OK'
-    end
-
-    def []=(key, value)
-      set(key, value)
-    end
-
-    def setbit(key, offset, value)
-      assert_stringy(key, "ERR bit is not an integer or out of range")
-      retval = getbit(key, offset)
-
-      str = data[key] || ""
-
-      offset_of_byte = offset / 8
-      offset_within_byte = offset % 8
-
-      if offset_of_byte >= str.bytesize
-        str = zero_pad(str, offset_of_byte+1)
-      end
-
-      char_index = byte_index = offset_within_char = 0
-      str.each_char do |c|
-        if byte_index < offset_of_byte
-          char_index += 1
-          byte_index += c.bytesize
-        else
-          offset_within_char = byte_index - offset_of_byte
-          break
-        end
-      end
-
-      char = str[char_index]
-      char = char.chr if char.respond_to?(:chr)  # ruby 1.8 vs 1.9
-      char_as_number = char.each_byte.reduce(0) do |a, byte|
-        (a << 8) + byte
-      end
-      char_as_number |=
-        (2**((char.bytesize * 8)-1) >>
-        (offset_within_char * 8 + offset_within_byte))
-      str[char_index] = char_as_number.chr
-
-      data[key] = str
-      retval
-    end
-
-    def setex(key, seconds, value)
-      set(key, value)
-      expire(key, seconds)
-      'OK'
-    end
-
-    def setnx(key, value)
-      if exists(key)
-        false
-      else
-        set(key, value)
-        true
-      end
-    end
-
-    def setrange(key, offset, value)
-      assert_stringy(key)
-      value = value.to_s
-      old_value = (data[key] || "")
-
-      prefix = zero_pad(old_value[0...offset], offset)
-      data[key] = prefix + value + (old_value[(offset + value.length)..-1] || "")
-      data[key].length
-    end
-
-    def strlen(key)
-      assert_stringy(key)
-      (data[key] || "").bytesize
-    end
-
-
-
-
-    private
-    def stringy?(key)
-      data[key].nil? || data[key].kind_of?(String)
-    end
-
-    def assert_stringy(key,
-        message="ERR Operation against a key holding the wrong kind of value")
-      unless stringy?(key)
-        raise RuntimeError, message
-      end
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/transaction_wrapper.rb

@@ -1,80 +0,0 @@
-require 'mock_redis/undef_redis_methods'
-
-class MockRedis
-  class TransactionWrapper
-    include UndefRedisMethods
-
-    def respond_to?(method, include_private=false)
-      super || @db.respond_to?(method)
-    end
-
-    def initialize(db)
-      @db = db
-      @queued_commands = []
-      @in_multi = false
-    end
-
-    def method_missing(method, *args)
-      if @in_multi
-        @queued_commands << [method, *args]
-        'QUEUED'
-      else
-        @db.expire_keys
-        @db.send(method, *args)
-      end
-    end
-
-    def initialize_copy(source)
-      super
-      @db = @db.clone
-      @queued_commands = @queued_commands.clone
-    end
-
-    def discard
-      unless @in_multi
-        raise RuntimeError, "ERR DISCARD without MULTI"
-      end
-      @in_multi = false
-      @queued_commands = []
-      'OK'
-    end
-
-    def exec
-      unless @in_multi
-        raise RuntimeError, "ERR EXEC without MULTI"
-      end
-      @in_multi = false
-      responses = @queued_commands.map do |cmd|
-        begin
-          send(*cmd)
-        rescue => e
-          e
-        end
-      end
-      @queued_commands = []
-      responses
-    end
-
-    def multi
-      if @in_multi
-        raise RuntimeError, "ERR MULTI calls can not be nested"
-      end
-      @in_multi = true
-      if block_given?
-        yield(self)
-        self.exec
-      else
-        'OK'
-      end
-    end
-
-    def unwatch
-      'OK'
-    end
-
-    def watch(_)
-      'OK'
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/undef_redis_methods.rb

@@ -1,11 +0,0 @@
-class MockRedis
-  module UndefRedisMethods
-    def self.included(klass)
-      if klass.instance_methods.map(&:to_s).include?('type')
-        klass.send(:undef_method, 'type')
-      end
-      klass.send(:undef_method, 'exec')
-      klass.send(:undef_method, 'select')
-    end
-  end
-end

data/spec/mock_redis/lib/mock_redis/utility_methods.rb

@@ -1,25 +0,0 @@
-class MockRedis
-  module UtilityMethods
-    private
-
-    def with_thing_at(key, assertion, empty_thing_generator)
-      begin
-        send(assertion, key)
-        data[key] ||= empty_thing_generator.call
-        data_key_ref = data[key]
-        ret = yield data[key]
-        data[key] = data_key_ref if data[key].nil?
-        ret
-      ensure
-        clean_up_empties_at(key)
-      end
-    end
-
-    def clean_up_empties_at(key)
-      if data[key] && data[key].empty?
-        del(key)
-      end
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/version.rb

@@ -1,3 +0,0 @@
-class MockRedis
-  VERSION = '0.4.1'
-end

data/spec/mock_redis/lib/mock_redis/zset.rb

@@ -1,110 +0,0 @@
-require 'forwardable'
-require 'set'
-
-class MockRedis
-  class Zset
-    include Enumerable
-    extend Forwardable
-
-    attr_reader :members, :scores
-
-    def_delegators :members, :empty?, :include?, :size
-
-    def initialize
-      @members = Set.new
-      @scores  = Hash.new
-    end
-
-    def initialize_copy(source)
-      super
-      @members = @members.clone
-      @scores  = @scores.clone
-    end
-
-    def add(score, member)
-      members.add(member)
-      if score.to_f.to_i == score.to_f
-        scores[member] = score.to_f.to_i
-      else
-        scores[member] = score.to_f
-      end
-      self
-    end
-
-    def delete?(member)
-      scores.delete(member)
-      members.delete?(member) and self
-    end
-
-    def each
-      members.each {|m| yield score(m), m}
-    end
-
-    def in_range(min, max)
-      in_from_the_left = case min
-                         when "-inf"
-                             lambda {|_| true }
-                         when "+inf"
-                             lambda {|_| false }
-                         when /\((.*)$/
-                             val = $1.to_f
-                           lambda {|x| x.to_f > val }
-                         else
-                           lambda {|x| x.to_f >= min.to_f }
-                         end
-
-      in_from_the_right = case max
-                          when "-inf"
-                              lambda {|_| false }
-                          when "+inf"
-                              lambda {|_| true }
-                          when /\((.*)$/
-                              val = $1.to_f
-                            lambda {|x| x.to_f < val }
-                          else
-                            lambda {|x| x.to_f <= max.to_f }
-                          end
-
-      sorted.find_all do |(score, member)|
-        in_from_the_left[score] && in_from_the_right[score]
-      end
-    end
-
-    def intersection(other)
-      if !block_given?
-        intersection(other, &:+)
-      else
-        self.members.intersection(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
-          acc.add(new_score, m)
-        end
-      end
-    end
-
-    def score(member)
-      scores[member]
-    end
-
-    def sorted
-      members.map do |m|
-        [score(m), m]
-      end.sort_by(&:first)
-    end
-
-    def sorted_members
-      sorted.map(&:last)
-    end
-
-    def union(other)
-      if !block_given?
-        union(other, &:+)
-      else
-        self.members.union(other.members).reduce(self.class.new) do |acc, m|
-          new_score = yield(self.score(m), other.score(m))
-          acc.add(new_score, m)
-        end
-      end
-    end
-
-  end
-end

data/spec/mock_redis/lib/mock_redis/zset_methods.rb

@@ -1,210 +0,0 @@
-require 'mock_redis/assertions'
-require 'mock_redis/utility_methods'
-require 'mock_redis/zset'
-
-class MockRedis
-  module ZsetMethods
-    include Assertions
-    include UtilityMethods
-
-    def zadd(key, score, member)
-      assert_scorey(score)
-
-      retval = !zscore(key, member)
-      with_zset_at(key) {|z| z.add(score, member.to_s)}
-      retval
-    end
-
-    def zcard(key)
-      with_zset_at(key, &:size)
-    end
-
-    def zcount(key, min, max)
-      assert_scorey(min, 'min or max')
-      assert_scorey(max, 'min or max')
-
-      with_zset_at(key) do |z|
-        z.count do |score, _|
-          score >= min && score <= max
-        end
-      end
-    end
-
-    def zincrby(key, increment, member)
-      assert_scorey(increment)
-      member = member.to_s
-      with_zset_at(key) do |z|
-        old_score = z.include?(member) ? z.score(member) : 0
-        new_score = old_score + increment
-        z.add(new_score, member)
-        new_score.to_s
-      end
-    end
-
-    def zinterstore(destination, keys, options={})
-      assert_has_args(keys, 'zinterstore')
-
-      data[destination] = combine_weighted_zsets(keys, options, :intersection)
-      zcard(destination)
-    end
-
-    def zrange(key, start, stop, options={})
-      with_zset_at(key) do |z|
-        to_response(z.sorted[start..stop] || [], options)
-      end
-    end
-
-    def zrangebyscore(key, min, max, options={})
-      with_zset_at(key) do |zset|
-        all_results = zset.in_range(min, max)
-        to_response(apply_limit(all_results, options[:limit]), options)
-      end
-    end
-
-    def zrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.index(member.to_s) }
-    end
-
-    def zrem(key, member)
-      with_zset_at(key) {|z| !!z.delete?(member.to_s)}
-    end
-
-    def zrevrange(key, start, stop, options={})
-      with_zset_at(key) do |z|
-        to_response(z.sorted.reverse[start..stop], options)
-      end
-    end
-
-    def zremrangebyrank(key, start, stop)
-      zrange(key, start, stop).
-        each {|member| zrem(key, member)}.
-        size
-    end
-
-    def zremrangebyscore(key, min, max)
-      zrangebyscore(key, min, max).
-        each {|member| zrem(key, member)}.
-        size
-    end
-
-    def zrevrangebyscore(key, max, min, options={})
-      with_zset_at(key) do |zset|
-        to_response(
-          apply_limit(
-            zset.in_range(min, max).reverse,
-            options[:limit]),
-          options)
-      end
-    end
-
-    def zrevrank(key, member)
-      with_zset_at(key) {|z| z.sorted_members.reverse.index(member.to_s) }
-    end
-
-    def zscore(key, member)
-      with_zset_at(key) do |z|
-        score = z.score(member.to_s)
-        score.to_s if score
-      end
-    end
-
-    def zunionstore(destination, keys, options={})
-      assert_has_args(keys, 'zunionstore')
-
-      data[destination] = combine_weighted_zsets(keys, options, :union)
-      zcard(destination)
-    end
-
-    private
-    def apply_limit(collection, limit)
-      if limit
-        if limit.is_a?(Array) && limit.length == 2
-          offset, count = limit
-          collection.drop(offset).take(count)
-        else
-          raise RuntimeError, "ERR syntax error"
-        end
-      else
-        collection
-      end
-    end
-
-    def to_response(score_member_pairs, options)
-      score_member_pairs.map do |(score,member)|
-        if options[:with_scores] || options[:withscores]
-          [member, score.to_s]
-        else
-          member
-        end
-      end.flatten
-    end
-
-    def combine_weighted_zsets(keys, options, how)
-      weights = options.fetch(:weights, keys.map { 1 })
-      if weights.length != keys.length
-        raise RuntimeError, "ERR syntax error"
-      end
-
-      aggregator = case options.fetch(:aggregate, :sum).to_s.downcase.to_sym
-                   when :sum
-                     proc {|a,b| [a,b].compact.reduce(&:+)}
-                   when :min
-                     proc {|a,b| [a,b].compact.min}
-                   when :max
-                     proc {|a,b| [a,b].compact.max}
-                   else
-                     raise RuntimeError, "ERR syntax error"
-                   end
-
-      with_zsets_at(*keys) do |*zsets|
-        zsets.zip(weights).map do |(zset, weight)|
-          zset.reduce(Zset.new) do |acc, (score, member)|
-            acc.add(score * weight, member)
-          end
-        end.reduce do |za, zb|
-          za.send(how, zb, &aggregator)
-        end
-      end
-
-    end
-
-    def with_zset_at(key, &blk)
-      with_thing_at(key, :assert_zsety, proc {Zset.new}, &blk)
-    end
-
-    def with_zsets_at(*keys, &blk)
-      if keys.length == 1
-        with_zset_at(keys.first, &blk)
-      else
-        with_zset_at(keys.first) do |set|
-          with_zsets_at(*(keys[1..-1])) do |*sets|
-            blk.call(*([set] + sets))
-          end
-        end
-      end
-    end
-
-    def zsety?(key)
-      data[key].nil? || data[key].kind_of?(Zset)
-    end
-
-    def assert_zsety(key)
-      unless zsety?(key)
-        raise RuntimeError,
-        "ERR Operation against a key holding the wrong kind of value"
-      end
-    end
-
-    def looks_like_float?(x)
-      # ugh, exceptions for flow control.
-      !!Float(x) rescue false
-    end
-
-    def assert_scorey(value, what='value')
-      unless looks_like_float?(value)
-        raise RuntimeError, "ERR #{what} is not a double"
-      end
-    end
-
-  end
-end