familia 1.2.1 → 2.0.0.pre.pre

data/lib/familia/{redistype → datatype}/types/hashkey.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
+# lib/familia/datatype/types/hashkey.rb
 
 module Familia
-  class HashKey < RedisType
+  class HashKey < DataType
     # Returns the number of fields in the hash
     # @return [Integer] number of fields
     def field_count
-      redis.hlen rediskey
+      dbclient.hlen dbkey
     end
     alias size field_count
 
@@ -16,22 +16,22 @@ module Familia
     # +return+ [Integer] Returns 1 if the field is new and added, 0 if the
     #  field already existed and the value was updated.
     def []=(field, val)
-      ret = redis.hset rediskey, field.to_s, serialize_value(val)
+      ret = dbclient.hset dbkey, field.to_s, serialize_value(val)
       update_expiration
       ret
     rescue TypeError => e
       Familia.le "[hset]= #{e.message}"
-      Familia.ld "[hset]= #{rediskey} #{field}=#{val}" if Familia.debug
-      echo :hset, caller(1..1).first if Familia.debug # logs via echo to redis and back
+      Familia.ld "[hset]= #{dbkey} #{field}=#{val}" if Familia.debug
+      echo :hset, caller(1..1).first if Familia.debug # logs via echo to the db and back
       klass = val.class
-      msg = "Cannot store #{field} => #{val.inspect} (#{klass}) in #{rediskey}"
+      msg = "Cannot store #{field} => #{val.inspect} (#{klass}) in #{dbkey}"
       raise e.class, msg
     end
     alias put []=
     alias store []=
 
     def [](field)
-      deserialize_value redis.hget(rediskey, field.to_s)
+      deserialize_value dbclient.hget(dbkey, field.to_s)
     end
     alias get []
 
@@ -47,22 +47,22 @@ module Familia
     end
 
     def keys
-      redis.hkeys rediskey
+      dbclient.hkeys dbkey
     end
 
     def values
-      redis.hvals(rediskey).map { |v| deserialize_value v }
+      dbclient.hvals(dbkey).map { |v| deserialize_value v }
     end
 
     def hgetall
-      redis.hgetall(rediskey).each_with_object({}) do |(k,v), ret|
+      dbclient.hgetall(dbkey).each_with_object({}) do |(k,v), ret|
         ret[k] = deserialize_value v
       end
     end
     alias all hgetall
 
     def key?(field)
-      redis.hexists rediskey, field.to_s
+      dbclient.hexists dbkey, field.to_s
     end
     alias has_key? key?
     alias include? key?
@@ -72,12 +72,12 @@ module Familia
     # @param field [String] The field to remove
     # @return [Integer] The number of fields that were removed (0 or 1)
     def remove_field(field)
-      redis.hdel rediskey, field.to_s
+      dbclient.hdel dbkey, field.to_s
     end
     alias remove remove_field # deprecated
 
     def increment(field, by = 1)
-      redis.hincrby(rediskey, field.to_s, by).to_i
+      dbclient.hincrby(dbkey, field.to_s, by).to_i
     end
     alias incr increment
     alias incrby increment
@@ -93,7 +93,7 @@ module Familia
 
       data = hsh.inject([]) { |ret, pair| ret << [pair[0], serialize_value(pair[1])] }.flatten
 
-      ret = redis.hmset(rediskey, *data)
+      ret = dbclient.hmset(dbkey, *data)
       update_expiration
       ret
     end
@@ -101,11 +101,11 @@ module Familia
 
     def values_at *fields
       string_fields = fields.flatten.compact.map(&:to_s)
-      elements = redis.hmget(rediskey, *string_fields)
+      elements = dbclient.hmget(dbkey, *string_fields)
       deserialize_values(*elements)
     end
 
-    # The Great Redis Refresh-o-matic 3000 for HashKey!
+    # The Great Database Refresh-o-matic 3000 for HashKey!
     #
     # This method performs a complete refresh of the hash's state from Redis.
     # It's like giving your hash a memory transfusion - out with the old state,
@@ -117,7 +117,7 @@ module Familia
     # @return [void] Returns nothing, but your hash will be sparkling clean
     #   with all its fields synchronized with Redis.
     #
-    # @raise [Familia::KeyNotFoundError] If the Redis key for this hash no
+    # @raise [Familia::KeyNotFoundError] If the dbkey for this hash no
     #   longer exists. Time travelers beware!
     #
     # @example Basic usage
@@ -127,14 +127,14 @@ module Familia
     #   begin
     #     my_hash.refresh!
     #   rescue Familia::KeyNotFoundError
-    #     puts "Oops! Our hash seems to have vanished into the Redis void!"
+    #     puts "Oops! Our hash seems to have vanished into the Database void!"
     #   end
     def refresh!
-      Familia.trace :REFRESH, redis, redisuri, caller(1..1) if Familia.debug?
-      raise Familia::KeyNotFoundError, rediskey unless redis.exists(rediskey)
+      Familia.trace :REFRESH, dbclient, uri, caller(1..1) if Familia.debug?
+      raise Familia::KeyNotFoundError, dbkey unless dbclient.exists(dbkey)
 
       fields = hgetall
-      Familia.ld "[refresh!] #{self.class} #{rediskey} #{fields.keys}"
+      Familia.ld "[refresh!] #{self.class} #{dbkey} #{fields.keys}"
 
       # For HashKey, we update by merging the fresh data
       update(fields)
@@ -148,7 +148,7 @@ module Familia
     #
     # @return [self] Returns the refreshed hash, ready for more adventures!
     #
-    # @raise [Familia::KeyNotFoundError] If the Redis key does not exist.
+    # @raise [Familia::KeyNotFoundError] If the dbkey does not exist.
     #   The hash must exist in Redis-land for this to work!
     #
     # @example Refresh and chain
@@ -161,7 +161,7 @@ module Familia
       self
     end
 
-    Familia::RedisType.register self, :hash # legacy, deprecated
-    Familia::RedisType.register self, :hashkey
+    Familia::DataType.register self, :hash # legacy, deprecated
+    Familia::DataType.register self, :hashkey
   end
 end

data/lib/familia/{redistype → datatype}/types/list.rb

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
+# lib/familia/datatype/types/list.rb
 
 module Familia
-  class List < RedisType
+  class List < DataType
 
     # Returns the number of elements in the list
     # @return [Integer] number of elements
     def element_count
-      redis.llen rediskey
+      dbclient.llen dbkey
     end
     alias size element_count
 
@@ -16,8 +16,8 @@ module Familia
 
     def push *values
       echo :push, caller(1..1).first if Familia.debug
-      values.flatten.compact.each { |v| redis.rpush rediskey, serialize_value(v) }
-      redis.ltrim rediskey, -@opts[:maxlength], -1 if @opts[:maxlength]
+      values.flatten.compact.each { |v| dbclient.rpush dbkey, serialize_value(v) }
+      dbclient.ltrim dbkey, -@opts[:maxlength], -1 if @opts[:maxlength]
       update_expiration
       self
     end
@@ -29,20 +29,20 @@ module Familia
     alias add <<
 
     def unshift *values
-      values.flatten.compact.each { |v| redis.lpush rediskey, serialize_value(v) }
+      values.flatten.compact.each { |v| dbclient.lpush dbkey, serialize_value(v) }
       # TODO: test maxlength
-      redis.ltrim rediskey, 0, @opts[:maxlength] - 1 if @opts[:maxlength]
+      dbclient.ltrim dbkey, 0, @opts[:maxlength] - 1 if @opts[:maxlength]
       update_expiration
       self
     end
     alias prepend unshift
 
     def pop
-      deserialize_value redis.rpop(rediskey)
+      deserialize_value dbclient.rpop(dbkey)
     end
 
     def shift
-      deserialize_value redis.lpop(rediskey)
+      deserialize_value dbclient.lpop(dbkey)
     end
 
     def [](idx, count = nil)
@@ -65,7 +65,7 @@ module Familia
     # @param count [Integer] Number of elements to remove (0 means all)
     # @return [Integer] The number of removed elements
     def remove_element(value, count = 0)
-      redis.lrem rediskey, count, serialize_value(value)
+      dbclient.lrem dbkey, count, serialize_value(value)
     end
     alias remove remove_element
 
@@ -75,7 +75,7 @@ module Familia
     end
 
     def rangeraw(sidx = 0, eidx = -1)
-      redis.lrange(rediskey, sidx, eidx)
+      dbclient.lrange(dbkey, sidx, eidx)
     end
 
     def members(count = -1)
@@ -124,7 +124,7 @@ module Familia
     end
 
     def at(idx)
-      deserialize_value redis.lindex(rediskey, idx)
+      deserialize_value dbclient.lindex(dbkey, idx)
     end
 
     def first
@@ -157,6 +157,6 @@ module Familia
     #  end
     # end
 
-    Familia::RedisType.register self, :list
+    Familia::DataType.register self, :list
   end
 end

data/lib/familia/{redistype → datatype}/types/sorted_set.rb

@@ -1,11 +1,11 @@
-# frozen_string_literal: true
+# lib/familia/datatype/types/sorted_set.rb
 
 module Familia
-  class SortedSet < RedisType
+  class SortedSet < DataType
     # Returns the number of elements in the sorted set
     # @return [Integer] number of elements
     def element_count
-      redis.zcard rediskey
+      dbclient.zcard dbkey
     end
     alias size element_count
 
@@ -46,32 +46,32 @@ module Familia
     end
 
     def add(score, val)
-      ret = redis.zadd rediskey, score, serialize_value(val)
+      ret = dbclient.zadd dbkey, score, serialize_value(val)
       update_expiration
       ret
     end
 
     def score(val)
-      ret = redis.zscore rediskey, serialize_value(val, strict_values: false)
+      ret = dbclient.zscore dbkey, serialize_value(val, strict_values: false)
       ret&.to_f
     end
     alias [] score
 
     def member?(val)
-      Familia.trace :MEMBER, redis, "#{val}<#{val.class}>", caller(1..1) if Familia.debug?
+      Familia.trace :MEMBER, dbclient, "#{val}<#{val.class}>", caller(1..1) if Familia.debug?
       !rank(val).nil?
     end
     alias include? member?
 
     # rank of member +v+ when ordered lowest to highest (starts at 0)
     def rank(v)
-      ret = redis.zrank rediskey, serialize_value(v, strict_values: false)
+      ret = dbclient.zrank dbkey, serialize_value(v, strict_values: false)
       ret&.to_i
     end
 
     # rank of member +v+ when ordered highest to lowest (starts at 0)
     def revrank(v)
-      ret = redis.zrevrank rediskey, serialize_value(v, strict_values: false)
+      ret = dbclient.zrevrank dbkey, serialize_value(v, strict_values: false)
       ret&.to_i
     end
 
@@ -140,12 +140,12 @@ module Familia
     def rangeraw(sidx, eidx, opts = {})
       # NOTE: :withscores (no underscore) is the correct naming for the
       # redis-4.x gem. We pass :withscores through explicitly b/c
-      # redis.zrange et al only accept that one optional argument.
+      # dbclient.zrange et al only accept that one optional argument.
       # Passing `opts`` through leads to an ArgumentError:
       #
       #   sorted_sets.rb:374:in `zrevrange': wrong number of arguments (given 4, expected 3) (ArgumentError)
       #
-      redis.zrange(rediskey, sidx, eidx, **opts)
+      dbclient.zrange(dbkey, sidx, eidx, **opts)
     end
 
     def revrange(sidx, eidx, opts = {})
@@ -155,7 +155,7 @@ module Familia
     end
 
     def revrangeraw(sidx, eidx, opts = {})
-      redis.zrevrange(rediskey, sidx, eidx, **opts)
+      dbclient.zrevrange(dbkey, sidx, eidx, **opts)
     end
 
     # e.g. obj.metrics.rangebyscore (now-12.hours), now, :limit => [0, 10]
@@ -167,7 +167,7 @@ module Familia
 
     def rangebyscoreraw(sscore, escore, opts = {})
       echo :rangebyscoreraw, caller(1..1).first if Familia.debug
-      redis.zrangebyscore(rediskey, sscore, escore, **opts)
+      dbclient.zrangebyscore(dbkey, sscore, escore, **opts)
     end
 
     # e.g. obj.metrics.revrangebyscore (now-12.hours), now, :limit => [0, 10]
@@ -180,19 +180,19 @@ module Familia
     def revrangebyscoreraw(sscore, escore, opts = {})
       echo :revrangebyscoreraw, caller(1..1).first if Familia.debug
       opts[:with_scores] = true if opts[:withscores]
-      redis.zrevrangebyscore(rediskey, sscore, escore, opts)
+      dbclient.zrevrangebyscore(dbkey, sscore, escore, opts)
     end
 
     def remrangebyrank(srank, erank)
-      redis.zremrangebyrank rediskey, srank, erank
+      dbclient.zremrangebyrank dbkey, srank, erank
     end
 
     def remrangebyscore(sscore, escore)
-      redis.zremrangebyscore rediskey, sscore, escore
+      dbclient.zremrangebyscore dbkey, sscore, escore
     end
 
     def increment(val, by = 1)
-      redis.zincrby(rediskey, by, val).to_i
+      dbclient.zincrby(dbkey, by, val).to_i
     end
     alias incr increment
     alias incrby increment
@@ -207,13 +207,13 @@ module Familia
     # @param value The value to remove from the sorted set
     # @return [Integer] The number of members that were removed (0 or 1)
     def remove_element(value)
-      Familia.trace :REMOVE_ELEMENT, redis, "#{value}<#{value.class}>", caller(1..1) if Familia.debug?
+      Familia.trace :REMOVE_ELEMENT, dbclient, "#{value}<#{value.class}>", caller(1..1) if Familia.debug?
       # We use `strict_values: false` here to allow for the deletion of values
       # that are in the sorted set. If it's a horreum object, the value is
       # the identifier and not a serialized version of the object. So either
       # the value exists in the sorted set or it doesn't -- we don't need to
       # raise an error if it's not found.
-      redis.zrem rediskey, serialize_value(value, strict_values: false)
+      dbclient.zrem dbkey, serialize_value(value, strict_values: false)
     end
     alias remove remove_element # deprecated
 
@@ -231,7 +231,7 @@ module Familia
       at(-1)
     end
 
-    Familia::RedisType.register self, :sorted_set
-    Familia::RedisType.register self, :zset
+    Familia::DataType.register self, :sorted_set
+    Familia::DataType.register self, :zset
   end
 end

data/lib/familia/{redistype → datatype}/types/string.rb

@@ -1,7 +1,7 @@
-# frozen_string_literal: true
+# lib/familia/datatype/types/string.rb
 
 module Familia
-  class String < RedisType
+  class String < DataType
     def init; end
 
     # Returns the number of elements in the list
@@ -17,22 +17,23 @@ module Familia
 
     def value
       echo :value, caller(0..0) if Familia.debug
-      redis.setnx rediskey, @opts[:default] if @opts[:default]
-      deserialize_value redis.get(rediskey)
+      dbclient.setnx dbkey, @opts[:default] if @opts[:default]
+      deserialize_value dbclient.get(dbkey)
     end
     alias content value
     alias get value
 
     def to_s
-      value.to_s # value can return nil which to_s should not
+      return super if value.to_s.empty?
+      value.to_s
     end
 
     def to_i
-      value.to_i
+      value&.to_i || 0
     end
 
     def value=(val)
-      ret = redis.set(rediskey, serialize_value(val))
+      ret = dbclient.set(dbkey, serialize_value(val))
       update_expiration
       ret
     end
@@ -40,68 +41,68 @@ module Familia
     alias set value=
 
     def setnx(val)
-      ret = redis.setnx(rediskey, serialize_value(val))
+      ret = dbclient.setnx(dbkey, serialize_value(val))
       update_expiration
       ret
     end
 
     def increment
-      ret = redis.incr(rediskey)
+      ret = dbclient.incr(dbkey)
       update_expiration
       ret
     end
     alias incr increment
 
     def incrementby(val)
-      ret = redis.incrby(rediskey, val.to_i)
+      ret = dbclient.incrby(dbkey, val.to_i)
       update_expiration
       ret
     end
     alias incrby incrementby
 
     def decrement
-      ret = redis.decr rediskey
+      ret = dbclient.decr dbkey
       update_expiration
       ret
     end
     alias decr decrement
 
     def decrementby(val)
-      ret = redis.decrby rediskey, val.to_i
+      ret = dbclient.decrby dbkey, val.to_i
       update_expiration
       ret
     end
     alias decrby decrementby
 
     def append(val)
-      ret = redis.append rediskey, val
+      ret = dbclient.append dbkey, val
       update_expiration
       ret
     end
     alias << append
 
     def getbit(offset)
-      redis.getbit rediskey, offset
+      dbclient.getbit dbkey, offset
     end
 
     def setbit(offset, val)
-      ret = redis.setbit rediskey, offset, val
+      ret = dbclient.setbit dbkey, offset, val
       update_expiration
       ret
     end
 
     def getrange(spoint, epoint)
-      redis.getrange rediskey, spoint, epoint
+      dbclient.getrange dbkey, spoint, epoint
     end
 
     def setrange(offset, val)
-      ret = redis.setrange rediskey, offset, val
+      ret = dbclient.setrange dbkey, offset, val
       update_expiration
       ret
     end
 
     def getset(val)
-      ret = redis.getset rediskey, val
+      ret = dbclient.getset dbkey, val
       update_expiration
       ret
     end
@@ -110,8 +111,8 @@ module Familia
       value.nil?
     end
 
-    Familia::RedisType.register self, :string
-    Familia::RedisType.register self, :counter
-    Familia::RedisType.register self, :lock
+    Familia::DataType.register self, :string
+    Familia::DataType.register self, :counter
+    Familia::DataType.register self, :lock
   end
 end

data/lib/familia/{redistype → datatype}/types/unsorted_set.rb

@@ -1,12 +1,12 @@
-# frozen_string_literal: true
+# lib/familia/datatype/types/unsorted_set.rb
 
 module Familia
-  class Set < RedisType
+  class Set < DataType
 
     # Returns the number of elements in the unsorted set
     # @return [Integer] number of elements
     def element_count
-      redis.scard rediskey
+      dbclient.scard dbkey
     end
     alias size element_count
 
@@ -15,7 +15,7 @@ module Familia
     end
 
     def add *values
-      values.flatten.compact.each { |v| redis.sadd? rediskey, serialize_value(v) }
+      values.flatten.compact.each { |v| dbclient.sadd? dbkey, serialize_value(v) }
       update_expiration
       self
     end
@@ -33,7 +33,7 @@ module Familia
     alias to_a members
 
     def membersraw
-      redis.smembers(rediskey)
+      dbclient.smembers(dbkey)
     end
 
     def each(&blk)
@@ -69,7 +69,7 @@ module Familia
     end
 
     def member?(val)
-      redis.sismember rediskey, serialize_value(val)
+      dbclient.sismember dbkey, serialize_value(val)
     end
     alias include? member?
 
@@ -77,7 +77,7 @@ module Familia
     # @param value The value to remove from the set
     # @return [Integer] The number of members that were removed (0 or 1)
     def remove_element(value)
-      redis.srem rediskey, serialize_value(value)
+      dbclient.srem dbkey, serialize_value(value)
     end
     alias remove remove_element # deprecated
 
@@ -86,11 +86,11 @@ module Familia
     end
 
     def pop
-      redis.spop rediskey
+      dbclient.spop dbkey
     end
 
     def move(dstkey, val)
-      redis.smove rediskey, dstkey, val
+      dbclient.smove dbkey, dstkey, val
     end
 
     def random
@@ -98,7 +98,7 @@ module Familia
     end
 
     def randomraw
-      redis.srandmember(rediskey)
+      dbclient.srandmember(dbkey)
     end
 
     ## Make the value stored at KEY identical to the given list
@@ -122,6 +122,6 @@ module Familia
     #  end
     # end
 
-    Familia::RedisType.register self, :set
+    Familia::DataType.register self, :set
   end
 end