strc 0.0.2 → 0.0.3

data/README.rdoc

@@ -1,8 +1,13 @@
 = STRC - Super Terrible Redis Clone
 
-STRC is a poor attempt to make a native Ruby clone of Redis.  Why would you want that?  Well, who knows.  Maybe you don't feel like installing Redis for some reason.  Maybe you need to be able to run tests on a machine without having to install Redis.  Maybe you like badly implemented clones.
+STRC is a poor attempt to make a useless Ruby simulation of Redis.  Why would you want that?  Well, who knows.  Maybe you:
+* don't feel like installing Redis for some reason.  
+* need to be able to run tests on a machine without having to install Redis.  
+* like badly implemented clones.
 
-One thing STRC does kind of have going for it is that it's much more lazy in regards to what you give it.  Since you're passing it Ruby objects, that means you could just plop any old object in as a key or a value.  If that's something you're into.
+I'll come out and say it, there's little reason for this to exist, and it's not really written in a fashion that is what you'd call good.  It's just for shits and giggles.  If that's your thing, read on.
+
+One thing STRC does kind of have going for it is that it's much more lazy in regards to what you give it.  Since you're passing it Ruby objects, that means you could just plop any old object in as a key or a value, instead of just a string.  If that's something you're into.
 
 == Usage
 
@@ -41,29 +46,60 @@ Now you could start passing it commands, if they've been implemented.
     >> strc.smembers "stuff"
     => ["abc", "123"]
 
+=== Lists!
+    >> strc.rpush "poo", "abc", "xyz"
+    => 2
+    >> strc.lpush "poo", "123"
+    => 3
+    >> strc.rpop "poo"
+    => "xyz"
+    >> strc.llen "poo"
+    => 2
+
 == Command List
 Currently, the following commands are implemented:
 * get
 * set
+* setnx
 * del
 * exists
+* append
+* decr
+* decrby
+* incr
+* incrby
 * rename
 * renamenx
-* sadd
-* srem
-* sismember
-* smembers
-* scard
-* sinter
-* sinterstore
-* sdiff
-* sdiffstore
-* sunion
-* sunionstore
-* smove
-* srandmember
-* spop
+* Sets
+  * sadd
+  * srem
+  * sismember
+  * smembers
+  * scard
+  * sinter
+  * sinterstore
+  * sdiff
+  * sdiffstore
+  * sunion
+  * sunionstore
+  * smove
+  * srandmember
+  * spop
+* Lists
+  * lrange
+  * llen
+  * lpush
+  * lpushx
+  * lpop
+  * rpush
+  * rpushx
+  * rpop
+  * lindex
+  * lset
+  * ltrim
+  * rpoplpush
 
 == History
+* 0.0.3 - Some list commands done.
 * 0.0.2 - Set commands done.  Most general commands done.
 * 0.0.1 - Initial release.  Does some basic things.

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.0.3

data/lib/strc.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 class STRC
 	Exception = Class.new(StandardError)
 
@@ -11,11 +13,75 @@ class STRC
 		return "OK"
 	end
 
+	# Set the value of a key only if it doesn't already exist.
+	def setnx(key, value)
+		unless exists(key)
+			set(key, value)
+			return true
+		end
+		return false
+	end
+
 	# Get the value for the given key
 	def get(key)
 		@dict[key]
 	end
 
+	# Append a value to a key
+	def append(key, value)
+		if exists(key)
+			item = get(key)
+			if item.class == String and value.class == String
+				set(key, item + value)
+			else
+				raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
+			end
+		else
+			set(key, value)
+		end
+		return get(key).length
+	end
+
+	# Decrement an integer
+	def decr(key)
+		decrby(key, 1)
+	end
+
+	# Decrement an integer by a certain amount
+	def decrby(key, decrement)
+		unless exists(key)
+			set(key, 0)
+		end
+		value = get(key)
+		if value.class == Fixnum
+			set(key, value - decrement)
+		else
+			raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
+		end
+		get(key)
+	end
+
+	# Increment an integer
+	def incr(key)
+		incrby(key, 1)
+	end
+
+	# Increment an integer by a certain amount
+	def incrby(key, increment)
+		unless exists(key)
+			set(key, 0)
+		end
+		value = get(key)
+		if value.class == Fixnum
+			set(key, value + increment)
+		else
+			raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
+		end
+		get(key)
+	end
+
+	# Key commands!
+
 	# Delete a key
 	def del(*keys)
 		keys.each do |key|
@@ -54,22 +120,31 @@ class STRC
 		end
 	end
 
-	# Set functions!
+	# End of key commands~
+
+	# Set commands!
 
 	# Add a member to a set
 	def sadd(key, *args)
 		if args.length < 1
 			raise STRC::Exception.new "Wrong number of arguments (1 for 2)"
 		end
-		set = smembers(key)
-		@dict[key] = set + args
-		return args.length
+		set = sget(key)
+		added = 0
+		args.each do |arg|
+			unless set.include?(arg)
+				set << arg
+				added += 1
+			end
+		end
+		@dict[key] = set
+		return added
 	end
 
 	# Remove a member from a set
 	def srem(key, member)
 		if sismember(key, member)
-			@dict[key].delete_at(@dict[key].index(member))
+			@dict[key].delete(member)
 			return true
 		else
 			return false
@@ -80,13 +155,13 @@ class STRC
 	def sinter(*keys)
 		sets = []
 		keys.each do |key|
-			sets << smembers(key)
+			sets << sget(key)
 		end
 		inter = sets.shift
 		sets.each do |set|
 			inter &= set
 		end
-		return inter
+		return inter.to_a
 	end
 
 	# Similar to SINTER, but stores in destination instead of returning
@@ -100,13 +175,13 @@ class STRC
 	def sdiff(*keys)
 		sets = []
 		keys.each do |key|
-			sets << smembers(key)
+			sets << sget(key)
 		end
 		diff = sets.shift
 		sets.each do |set|
 			diff -= set
 		end
-		return diff
+		return diff.to_a
 	end
 
 	# Similar to SDIFF, but stores in destination instead of returning
@@ -117,7 +192,7 @@ class STRC
 
 	# Move an item from one set to another
 	def smove(source, destination, member)
-		if !sismember(source, member)
+		unless sismember(source, member)
 			return false
 		end
 		srem(source, member)
@@ -129,6 +204,15 @@ class STRC
 
 	# Returs a list of all unique items in the given sets
 	def sunion(*keys)
+		sets = []
+		keys.each do |key|
+			sets << sget(key)
+		end
+		union = sets.shift
+		sets.each do |set|
+			union += set
+		end
+		return union.to_a
 	end
 
 	# Similar to SUNION, but stores in destination instead of returning
@@ -139,7 +223,7 @@ class STRC
 
 	# Returns a random element from the set
 	def srandmember(key)
-		smembers(key).sample
+		sget(key).to_a.sample
 	end
 
 	# Randomly remove and return an item from the set
@@ -151,27 +235,136 @@ class STRC
 
 	# Determine if the given value is a member of the set at key
 	def sismember(key, member)
-		set = smembers(key)
-		return !set.index(member).nil?
+		set = sget(key)
+		return set.include?(member)
 	end
 
 	# Returns an array of members of the set
 	def smembers(key)
+		sget(key).to_a
+	end
+
+	# Gets the length of a set
+	def scard(key)
+		set = sget(key)
+		return set.length
+	end
+
+	# Gets a set.  Private
+	def sget(key)
 		if exists(key)
 			value = get(key)
-			if value.class == Array
+			if value.class == Set
 				return value
 			else
-				raise STRC::Exception .new "ERR Operation against a key holding the wrong kind of value"
+				raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
 			end
 		else
-			return []
+			return Set.new
 		end
 	end
 
-	# Gets the length of a set
-	def scard(key)
-		set = smembers(key)
-		return set.length
+	# End of set commands~
+
+	# List commands!
+
+	# Gets a list.  Private
+	def lget(key)
+		list = []
+		if exists(key)
+			list = get(key)
+			unless list.class == Array
+				raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"	
+			end
+		end
+		return list
+	end
+
+	# Returns elements from key in the given range
+	def lrange(key, start, stop)
+		list = lget(key)[start..stop]
+		return list.nil? ? [] : list
+	end
+
+	# Returns length of list
+	def llen(key)
+		lget(key).length
+	end
+
+	# Append values to a list
+	def rpush(key, *values)
+		list = lget(key)
+		list += values
+		set(key, list)
+		return list.length
+	end
+
+	# RPUSH if the list exists
+	def rpushx(key, *values)
+		if exists(key)
+			rpush(key, *values)
+		end
+	end
+
+	# Remove and get the last element in a list
+	def rpop(key)
+		list = lget(key)
+		element = list.pop
+		set(key, list)
+		return element
 	end
+
+	# Prepend values to a list
+	def lpush(key, *values)
+		list = lget(key)
+		list = values + list
+		set(key, list)
+		return list.length
+	end
+
+	# LPUSH if the list exists
+	def lpushx(key, *values)
+		if exists(key)
+			lpush(key, *values)
+		end
+	end
+
+	# Remove and get the first element in a list
+	def lpop(key)
+		list = lget(key)
+		element = list.shift
+		set(key, list)
+		return element
+	end
+
+	# Get an element from a list by its index
+	def lindex(key, index)
+		lget(key)[index]
+	end
+
+	# Set value for an element at index in a list
+	def lset(key, index, value)
+		list = lget(key)
+		list[index] = value
+		set(key, list)
+	end
+
+	# Trim a list to the specified range
+	def ltrim(key, start, stop)
+		set(key, lrange(key, start, stop))
+	end
+
+	# Removes an element from the end of one list and puts it at
+	# the beginning of another
+	def rpoplpush(source, destination)
+		lpush(destination, rpop(source))
+	end
+
+	# End of list commands~
+
+	# Hash commands!
+
+	# End of hash commands~
+
+	private :sget, :lget
 end

data/strc.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{strc}
-  s.version = "0.0.2"
+  s.version = "0.0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris O'Neal"]
-  s.date = %q{2011-07-14}
+  s.date = %q{2011-07-15}
   s.description = %q{STRC is a terrible Ruby clone of Redis}
   s.email = %q{ctoneal@gmail.com}
   s.extra_rdoc_files = [
@@ -28,6 +28,8 @@ Gem::Specification.new do |s|
     "strc.gemspec",
     "test/helper.rb",
     "test/test_basic_functions.rb",
+    "test/test_keys.rb",
+    "test/test_lists.rb",
     "test/test_sets.rb",
     "test/test_strc.rb"
   ]
@@ -39,6 +41,8 @@ Gem::Specification.new do |s|
   s.test_files = [
     "test/helper.rb",
     "test/test_basic_functions.rb",
+    "test/test_keys.rb",
+    "test/test_lists.rb",
     "test/test_sets.rb",
     "test/test_strc.rb"
   ]

data/test/test_basic_functions.rb

@@ -28,6 +28,21 @@ class TestBasicFunctions < Test::Unit::TestCase
 		end
 	end
 
+	context "setnx" do
+		should "be able to set the value of a new key" do
+			result = @test.setnx("test", 10)
+			assert(result)
+		end
+
+		should "not set value if the key already exists" do
+			@test.setnx("test", 10)
+			result = @test.setnx("test", 50)
+			assert(!result)
+			value = @test.get("test")
+			assert_equal(10, value)
+		end
+	end
+
 	context "get" do
 		should "be able to get the value of a key" do
 			@test.set("test_key", 15)
@@ -41,79 +56,83 @@ class TestBasicFunctions < Test::Unit::TestCase
 		end
 	end
 
-	context "exists" do
-		should "return true if the key exists" do
-			@test.set("test", 1)
-			assert(@test.exists("test"))
+	context "append" do
+		should "append to a string" do
+			@test.set("test", "Hello")
+			@test.append("test", " World")
+			value = @test.get("test")
+			assert_equal("Hello World", value)
 		end
 
-		should "return false if the key doesn't exist" do
-			assert(!@test.exists("test"))
+		should "return the new length of the string" do
+			@test.set("test", "Hello")
+			result = @test.append("test", " World")
+			assert_equal("Hello World".length, result)
 		end
-	end
 
-	context "del" do
-		should "delete a key" do
-			@test.set("test", 1)
-			deleted = @test.del("test")
-			assert_equal(1, deleted)
-			assert(!@test.exists("test"))
+		should "set if key doesn't exist" do
+			@test.append("test", "poop")
+			result = @test.get("test")
+			assert_equal("poop", result)
 		end
 
-		should "delete multiple keys" do
-			@test.set("test", 1)
-			@test.set("poop", 2)
-			@test.set("blah", 4)
-			deleted = @test.del("test", "poop")
-			assert_equal(2, deleted)
-			assert(!@test.exists("test"))
-			assert(!@test.exists("poop"))
-			assert(@test.exists("blah"))
+		should "not work for non string values" do
+			@test.set("test", 15)
+			assert_raise(STRC::Exception) { @test.append("test", "poop")}
 		end
 	end
 
-	context "randomkey" do
-		should "return a random key from the database" do
-			keys = ["test", "poop", "blah"]
-			keys.each do |key|
-				@test.set(key, 1)
-			end
-			random = @test.randomkey
-			assert_not_nil(keys.index(random))
+	context "incr" do
+		should "increment integers" do
+			@test.set("poop", 10)
+			@test.incr("poop")
+			assert_equal(11, @test.get("poop"))
 		end
-	end
 
-	context "rename" do
-		should "rename a key" do
-			@test.set("poop", 1)
-			@test.rename("poop", "abc")
-			value = @test.get("abc")
-			assert_equal(1, value)
+		should "not increment other types" do
+			@test.set("poop", "aaa")
+			assert_raise(STRC::Exception) { @test.incr("poop")}
 		end
 
-		should "overwrite existing keys" do
-			@test.set("poop", 1)
-			@test.set("abc", 2)
-			@test.rename("poop", "abc")
-			value = @test.get("abc")
-			assert_equal(1, value)
+		should "return new value" do
+			@test.set("poop", 10)
+			result = @test.incr("poop")
+			assert_equal(11, result)
 		end
 	end
 
-	context "renamenx" do
-		should "rename a key" do
-			@test.set("poop", 1)
-			@test.renamenx("poop", "abc")
-			value = @test.get("abc")
-			assert_equal(1, value)
+	context "incrby" do
+		should "be able to increment by value" do
+			@test.set("poop", 10)
+			@test.incrby("poop", 10)
+			assert_equal(20, @test.get("poop"))
 		end
+	end
+
+	context "decr" do
+		should "decrement integers" do
+			@test.set("poop", 10)
+			@test.decr("poop")
+			assert_equal(9, @test.get("poop"))
+		end
+
+		should "not decrement other types" do
+			@test.set("poop", "aaa")
+			assert_raise(STRC::Exception) { @test.decr("poop")}
+		end
+	
+		should "return new value" do
+			@test.set("poop", 10)
+			result = @test.decr("poop")
+			assert_equal(9, result)
+		end
+	end
 
-		should "not overwrite existing keys" do
-			@test.set("poop", 1)
-			@test.set("abc", 2)
-			@test.renamenx("poop", "abc")
-			value = @test.get("abc")
-			assert_equal(2, value)
+	context "decrby" do
+		should "be able to decrement by value" do
+			@test.set("poop", 10)
+			@test.decrby("poop", 10)
+			assert_equal(0, @test.get("poop"))
 		end
 	end
 end

data/test/test_keys.rb

@@ -0,0 +1,83 @@
+require 'helper'
+
+class TestKeys < Test::Unit::TestCase
+	def setup
+		@test = STRC.new
+	end
+	
+	context "exists" do
+		should "return true if the key exists" do
+			@test.set("test", 1)
+			assert(@test.exists("test"))
+		end
+
+		should "return false if the key doesn't exist" do
+			assert(!@test.exists("test"))
+		end
+	end
+
+	context "del" do
+		should "delete a key" do
+			@test.set("test", 1)
+			deleted = @test.del("test")
+			assert_equal(1, deleted)
+			assert(!@test.exists("test"))
+		end
+
+		should "delete multiple keys" do
+			@test.set("test", 1)
+			@test.set("poop", 2)
+			@test.set("blah", 4)
+			deleted = @test.del("test", "poop")
+			assert_equal(2, deleted)
+			assert(!@test.exists("test"))
+			assert(!@test.exists("poop"))
+			assert(@test.exists("blah"))
+		end
+	end
+
+	context "randomkey" do
+		should "return a random key from the database" do
+			keys = ["test", "poop", "blah"]
+			keys.each do |key|
+				@test.set(key, 1)
+			end
+			random = @test.randomkey
+			assert_not_nil(keys.index(random))
+		end
+	end
+
+	context "rename" do
+		should "rename a key" do
+			@test.set("poop", 1)
+			@test.rename("poop", "abc")
+			value = @test.get("abc")
+			assert_equal(1, value)
+		end
+
+		should "overwrite existing keys" do
+			@test.set("poop", 1)
+			@test.set("abc", 2)
+			@test.rename("poop", "abc")
+			value = @test.get("abc")
+			assert_equal(1, value)
+		end
+	end
+
+	context "renamenx" do
+		should "rename a key" do
+			@test.set("poop", 1)
+			@test.renamenx("poop", "abc")
+			value = @test.get("abc")
+			assert_equal(1, value)
+		end
+
+		should "not overwrite existing keys" do
+			@test.set("poop", 1)
+			@test.set("abc", 2)
+			@test.renamenx("poop", "abc")
+			value = @test.get("abc")
+			assert_equal(2, value)
+		end
+	end
+end

data/test/test_lists.rb

@@ -0,0 +1,151 @@
+require 'helper'
+
+class TestLists < Test::Unit::TestCase
+	def setup
+		@test = STRC.new
+		@test.rpush("poop", "a", "b", "c")
+	end
+
+	context "lrange" do
+		should "return a range of elements" do
+			result = @test.lrange("poop", 1, 2)
+			assert_equal(["b", "c"], result)
+		end
+
+		should "be zero based" do
+			result = @test.lrange("poop", 0, 0)
+			assert_equal(["a"], result)
+		end
+
+		should "work with negative numbers" do
+			result = @test.lrange("poop", -3, 2)
+			assert_equal(["a", "b", "c"], result)
+		end
+
+		should "indexing out should give an empty list" do
+			result = @test.lrange("poop", 5, 10)
+			assert_equal([], result)
+		end
+	end
+
+	context "llen" do
+		should "return length of the list" do
+			result = @test.llen("poop")
+			assert_equal(3, result)
+		end
+	end
+
+	context "rpush" do
+		should "create a new list" do
+			@test.rpush("asdf", "abc")
+			assert(@test.exists("asdf"))
+			assert_equal(["abc"], @test.lrange("asdf", 0, -1))
+		end
+
+		should "push onto the end of existing lists" do
+			@test.rpush("poop", "d", "e")
+			assert_equal(["a", "b", "c", "d", "e"], @test.lrange("poop", 0, -1))
+		end
+
+		should "return new length of list" do
+			len = @test.rpush("poop", "d", "e")
+			assert_equal(@test.lrange("poop", 0, -1).length, len)
+		end
+	end
+
+	context "rpushx" do
+		should "not be able to create a new list" do
+			@test.rpushx("asdf", "abc")
+			assert(!@test.exists("asdf"))
+		end
+	end
+
+	context "rpop" do
+		should "return the last element in the list" do
+			element = @test.rpop("poop")
+			assert_equal("c", element)
+		end
+
+		should "remove the last element in the list" do
+			@test.rpop("poop")
+			assert_equal(["a", "b"], @test.lrange("poop", 0, -1))
+		end
+	end
+
+	context "lpush" do
+		should "create a new list" do
+			@test.lpush("asdf", "abc")
+			assert(@test.exists("asdf"))
+			assert_equal(["abc"], @test.lrange("asdf", 0, -1))
+		end
+
+		should "push onto the beginning of existing lists" do
+			@test.lpush("poop", "d", "e")
+			assert_equal(["d", "e", "a", "b", "c"], @test.lrange("poop", 0, -1))
+		end
+
+		should "return new length of list" do
+			len = @test.lpush("poop", "d", "e")
+			assert_equal(@test.lrange("poop", 0, -1).length, len)
+		end
+	end
+
+	context "lpushx" do
+		should "not be able to create a new list" do
+			@test.lpushx("asdf", "abc")
+			assert(!@test.exists("asdf"))
+		end
+	end
+
+	context "lpop" do
+		should "return the first element in the list" do
+			element = @test.lpop("poop")
+			assert_equal("a", element)
+		end
+
+		should "remove the first element in the list" do
+			@test.lpop("poop")
+			assert_equal(["b", "c"], @test.lrange("poop", 0, -1))
+		end
+	end
+
+	context "lindex" do
+		should "return value at index" do
+			result = @test.lindex("poop", 1)
+			assert_equal("b", result)
+		end
+
+		should "work with negative numbers" do
+			result = @test.lindex("poop", -2)
+			assert_equal("b", result)
+		end
+
+		should "return nil for out of range" do
+			result = @test.lindex("poop", 10)
+			assert_nil(result)
+		end
+	end
+
+	context "lset" do
+		should "set value at index" do
+			@test.lset("poop", 2, "test")
+			assert_equal("test", @test.lindex("poop", 2))
+		end
+	end
+
+	context "ltrim" do
+		should "trim the list to the range" do
+			@test.ltrim("poop", 1, -1)
+			assert_equal(["b", "c"], @test.lrange("poop", 0, -1))
+		end
+	end
+
+	context "rpoplpush" do
+		should "take an element from the end of one list and put it on the front of another" do
+			@test.lpush("asdf", "123")
+			@test.rpoplpush("poop", "asdf")
+			assert_equal(["a", "b"], @test.lrange("poop", 0, -1))
+			assert_equal(["c", "123"], @test.lrange("asdf", 0, -1))
+		end
+	end
+end

data/test/test_sets.rb

@@ -129,6 +129,27 @@ class TestSets < Test::Unit::TestCase
 		end
 	end
 
+	context "sunion" do
+		should "give all unique members of given sets" do
+			@test.sadd("set1", "a", "b", "c", "d")
+			@test.sadd("set2", "c")
+			@test.sadd("set3", "a", "c", "e")
+			result = @test.sunion("set1", "set2", "set3")
+			assert_equal(["a", "b", "c", "d", "e"], result)
+		end
+	end
+
+	context "sunionstore" do
+		should "work like sunion, but store in destination" do
+			@test.sadd("set1", "a", "b", "c", "d")
+			@test.sadd("set2", "c")
+			@test.sadd("set3", "a", "c", "e")
+			@test.sunionstore("new", "set1", "set2", "set3")
+			result = @test.smembers("new")
+			assert_equal(["a", "b", "c", "d", "e"], result)
+		end
+	end
+
 	context "smove" do
 		should "move an item from one set to another" do
 			@test.sadd("set1", "one" ,"two")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strc
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-07-14 00:00:00.000000000 -05:00
+date: 2011-07-15 00:00:00.000000000 -05:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &9687480 !ruby/object:Gem::Requirement
+  requirement: &9732852 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9687480
+  version_requirements: *9732852
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &9686856 !ruby/object:Gem::Requirement
+  requirement: &9732216 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *9686856
+  version_requirements: *9732216
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &9685920 !ruby/object:Gem::Requirement
+  requirement: &9726516 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *9685920
+  version_requirements: *9726516
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &9644496 !ruby/object:Gem::Requirement
+  requirement: &9726036 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9644496
+  version_requirements: *9726036
 description: STRC is a terrible Ruby clone of Redis
 email: ctoneal@gmail.com
 executables: []
@@ -75,6 +75,8 @@ files:
 - strc.gemspec
 - test/helper.rb
 - test/test_basic_functions.rb
+- test/test_keys.rb
+- test/test_lists.rb
 - test/test_sets.rb
 - test/test_strc.rb
 has_rdoc: true
@@ -93,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 876690863
+      hash: 230414097
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -109,5 +111,7 @@ summary: Super Terrible Redis Clone
 test_files:
 - test/helper.rb
 - test/test_basic_functions.rb
+- test/test_keys.rb
+- test/test_lists.rb
 - test/test_sets.rb
 - test/test_strc.rb