sds / mock_redis / 7533551965

require 'mock_redis/assertions'

class MockRedis

  module StringMethods

    include Assertions

    include UtilityMethods

    def append(key, value)

      assert_stringy(key)

      data[key] ||= ''

      data[key] << value

      data[key].length

    def bitfield(*args)

      if args.length < 4

      key = args.shift

      output = []

      overflow_method = 'wrap'

      until args.empty?

        command = args.shift.to_s

        if command == 'overflow'

          new_overflow_method = args.shift.to_s.downcase

          unless %w[wrap sat fail].include? new_overflow_method

            raise Redis::CommandError, 'ERR Invalid OVERFLOW type specified'

          overflow_method = new_overflow_method

          next

        type, offset = args.shift(2)

        is_signed = type.slice(0) == 'i'

        type_size = type[1..].to_i

        if (type_size > 64 && is_signed) || (type_size >= 64 && !is_signed)

          raise Redis::CommandError,

        if offset.to_s[0] == '#'

          offset = offset[1..].to_i * type_size

        bits = []

        type_size.times do |i|

          bits.push(getbit(key, offset + i))

        val = is_signed ? twos_complement_decode(bits) : bits.join('').to_i(2)

        case command

          output.push(val)

          output.push(val)

          set_bitfield(key, args.shift.to_i, is_signed, type_size, offset)

          new_val = incr_bitfield(val, args.shift.to_i, is_signed, type_size, overflow_method)

          set_bitfield(key, new_val, is_signed, type_size, offset) if new_val

          output.push(new_val)

      output

    def decr(key)

      decrby(key, 1)

    def decrby(key, n)

      incrby(key, -n)

    def get(key)

      key = key.to_s

      assert_stringy(key)

      data[key]

    def getbit(key, offset)

      assert_stringy(key)

      offset = offset.to_i

      offset_of_byte = offset / 8

      offset_within_byte = offset % 8

      byte = (data[key] || '').each_byte.drop(offset_of_byte).first

      if byte

        (byte & (2**7 >> offset_within_byte)) > 0 ? 1 : 0

        0

    def getdel(key)

    def getrange(key, start, stop)

      assert_stringy(key)

      (data[key] || '')[start..stop]

    def getset(key, value)

      retval = get(key)

      set(key, value)

      retval

    def incr(key)

      incrby(key, 1)

    def incrby(key, n)

      assert_stringy(key)

      unless can_incr?(data[key])

        raise Redis::CommandError, 'ERR value is not an integer or out of range'

      unless looks_like_integer?(n.to_s)

        raise Redis::CommandError, 'ERR value is not an integer or out of range'

      new_value = data[key].to_i + n.to_i

      data[key] = new_value.to_s

      new_value

    def incrbyfloat(key, n)

      assert_stringy(key)

      unless can_incr_float?(data[key])

        raise Redis::CommandError, 'ERR value is not a valid float'

      unless looks_like_float?(n.to_s)

        raise Redis::CommandError, 'ERR value is not a valid float'

      new_value = data[key].to_f + n.to_f

      data[key] = new_value.to_s

      new_value

    def mget(*keys, &blk)

      keys.flatten!

      assert_has_args(keys, 'mget')

      data = keys.map do |key|

        get(key) if stringy?(key)

      blk ? blk.call(data) : data

    def mapped_mget(*keys)

      Hash[keys.zip(mget(*keys))]

    def mset(*kvpairs)

      assert_has_args(kvpairs, 'mset')

      kvpairs = kvpairs.first if kvpairs.size == 1 && kvpairs.first.is_a?(Enumerable)

      if kvpairs.length.odd?

        raise Redis::CommandError, 'ERR wrong number of arguments for MSET'

      kvpairs.each_slice(2) do |(k, v)|

        set(k, v)

      'OK'

    def mapped_mset(hash)

      mset(*hash.to_a.flatten)

    def msetnx(*kvpairs)

      assert_has_args(kvpairs, 'msetnx')

      if kvpairs.each_slice(2).any? { |(k, _)| exists?(k) }

        false

        mset(*kvpairs)

        true

    def mapped_msetnx(hash)

      msetnx(*hash.to_a.flatten)

    def set(key, value, ex: nil, px: nil, exat: nil, pxat: nil, nx: nil, xx: nil, keepttl: nil,

      key = key.to_s

      retval = self.get(key) if get

      return_true = false

      if nx

        if exists?(key)

          return false

          return_true = true

      if xx

        if exists?(key)

          return_true = true

          return false

      data[key] = value.to_s

      remove_expiration(key) unless keepttl

      if ex

        if ex == 0

          raise Redis::CommandError, 'ERR invalid expire time in set'

        expire(key, ex)

      if px

        if px == 0

          raise Redis::CommandError, 'ERR invalid expire time in set'

        pexpire(key, px)

      if exat

        if exat == 0

          raise Redis::CommandError, 'ERR invalid expire time in set'

        expireat(key, exat)

      if pxat

        if pxat == 0

          raise Redis::CommandError, 'ERR invalid expire time in set'

        pexpireat(key, pxat)

      if get

        retval

        return_true ? true : 'OK'

    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 = offset.to_i

      offset_of_byte = offset / 8

      offset_within_byte = offset % 8

      if offset_of_byte >= str.bytesize

        str = zero_pad(str, offset_of_byte + 1)

      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

          offset_within_char = byte_index - offset_of_byte

          break

      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

      bitmask_length = (char.bytesize * 8 - offset_within_char * 8 - offset_within_byte - 1)

      bitmask = 1 << bitmask_length

      if value.zero?

        bitmask ^= 2**(char.bytesize * 8) - 1

        char_as_number &= bitmask

        char_as_number |= bitmask

      str[char_index] = char_as_number.chr

      data[key] = str

      retval

    def bitcount(key, start = 0, stop = -1)

      assert_stringy(key)

      str   = data[key] || ''

      count = 0

      m1    = 0x5555555555555555

      m2    = 0x3333333333333333

      m4    = 0x0f0f0f0f0f0f0f0f

      m8    = 0x00ff00ff00ff00ff

      m16   = 0x0000ffff0000ffff

      m32   = 0x00000000ffffffff

      str.bytes.to_a[start..stop].each do |byte|

        c = byte

        c = (c & m1) + ((c >> 1) & m1)

        c = (c & m2) + ((c >> 2) & m2)

        c = (c & m4) + ((c >> 4) & m4)

        c = (c & m8) + ((c >> 8) & m8)

        c = (c & m16) + ((c >> 16) & m16)

        c = (c & m32) + ((c >> 32) & m32)

        count += c

      count

    def setex(key, seconds, value)

      if seconds <= 0

        raise Redis::CommandError, 'ERR invalid expire time in setex'

        set(key, value)

        expire(key, seconds)

        'OK'

    def psetex(key, milliseconds, value)

      if milliseconds <= 0

        raise Redis::CommandError, 'ERR invalid expire time in psetex'

        set(key, value)

        pexpire(key, milliseconds)

        'OK'

    def setnx(key, value)

      if exists?(key)

        false

        set(key, value)

        true

    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)..] || '')

      data[key].length

    def strlen(key)

      assert_stringy(key)

      (data[key] || '').bytesize

    private

    def stringy?(key)

      data[key].nil? || data[key].is_a?(String)

    def assert_stringy(key,

      unless stringy?(key)

        raise Redis::CommandError, message

    def set_bitfield(key, value, is_signed, type_size, offset)

      if is_signed

        val_array = twos_complement_encode(value, type_size)

        str = left_pad(value.to_i.abs.to_s(2), type_size)

        val_array = str.split('').map(&:to_i)

      val_array.each_with_index do |bit, i|

        setbit(key, offset + i, bit)

    def incr_bitfield(val, incrby, is_signed, type_size, overflow_method)

      new_val = val + incrby

      max = is_signed ? (2**(type_size - 1)) - 1 : (2**type_size) - 1

      min = is_signed ? (-2**(type_size - 1)) : 0

      size = 2**type_size

      return new_val if (min..max).cover?(new_val)

      case overflow_method

        new_val = nil

        new_val = new_val > max ? max : min

        if is_signed

          if new_val > max

            remainder = new_val - (max + 1)

            new_val = min + remainder.abs

            remainder = new_val - (min - 1)

            new_val = max - remainder.abs

          new_val = new_val > max ? new_val % size : size - new_val.abs

      new_val