strc 0.0.1 → 0.0.2

data/README.rdoc

@@ -8,38 +8,62 @@ One thing STRC does kind of have going for it is that it's much more lazy in reg
 
 STRC is distributed as a gem.  To install:
 
-	% gem install strc
+    % gem install strc
 
 Now you've got it all up in your computer.  To use:
 
-	require 'rubygems'
-	require 'strc'
+    require 'rubygems'
+    require 'strc'
 
-	strc = STRC.new
+    strc = STRC.new
 
 Now you could start passing it commands, if they've been implemented.
 
 === Getting and Setting!
-	>> strc.set "foo", "bar"
-	=> "OK"
-	>> strc.get "foo"
-	=> "bar"
+    >> strc.set "foo", "bar"
+    => "OK"
+    >> strc.get "foo"
+    => "bar"
 
 === Sets!
-	>> strc.sadd "stuff", "abc"
-	=> 1
-	>> strc.sadd "stuff", "123", "blah"
-	=> 2
-	>> strc.scard "stuff"
-	=> 3
-	>> strc.sismember "stuff", "abc"
-	=> true
-	>> strc.sismember "stuff", "xyz"
-	=> false
-	>> strc.srem "stuff", "blah"
-	=> true
-	>> strc.smembers "stuff"
-	=> ["abc", "123"]
+    >> strc.sadd "stuff", "abc"
+    => 1
+    >> strc.sadd "stuff", "123", "blah"
+    => 2
+    >> strc.scard "stuff"
+    => 3
+    >> strc.sismember "stuff", "abc"
+    => true
+    >> strc.sismember "stuff", "xyz"
+    => false
+    >> strc.srem "stuff", "blah"
+    => true
+    >> strc.smembers "stuff"
+    => ["abc", "123"]
+
+== Command List
+Currently, the following commands are implemented:
+* get
+* set
+* del
+* exists
+* rename
+* renamenx
+* sadd
+* srem
+* sismember
+* smembers
+* scard
+* sinter
+* sinterstore
+* sdiff
+* sdiffstore
+* sunion
+* sunionstore
+* smove
+* srandmember
+* spop
 
 == History
+* 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.1
+0.0.2

data/lib/strc.rb

@@ -16,20 +16,53 @@ class STRC
 		@dict[key]
 	end
 
+	# Delete a key
+	def del(*keys)
+		keys.each do |key|
+			@dict.delete(key)
+		end
+		return keys.length
+	end
+
+	# Returns if key exists
+	def exists(key)
+		@dict.has_key?(key)
+	end
+
+	# Returns a random key
+	def randomkey
+		@dict.keys.sample
+	end
+
+	# Renames a key.  Overwrites destination.
+	def rename(key, newkey)
+		if key == newkey
+			raise STRC::Exception.new "ERR Source and destination objects are the same"
+		end
+		@dict[newkey] = @dict[key]
+		del(key)
+		return "OK"
+	end
+
+	# Renames a key.  Does not overwrite destination.
+	def renamenx(key, newkey)
+		if exists(newkey)
+			return false
+		else
+			rename(key, newkey)
+			return true
+		end
+	end
+
+	# Set functions!
+
 	# 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
-		if @dict.has_key?(key)
-			if @dict[key].class == Array
-				@dict[key] << args
-			else
-				raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
-			end
-		else
-			@dict[key] = args
-		end
+		set = smembers(key)
+		@dict[key] = set + args
 		return args.length
 	end
 
@@ -43,23 +76,91 @@ class STRC
 		end
 	end
 
+	# Returns a list of m
+	def sinter(*keys)
+		sets = []
+		keys.each do |key|
+			sets << smembers(key)
+		end
+		inter = sets.shift
+		sets.each do |set|
+			inter &= set
+		end
+		return inter
+	end
+
+	# Similar to SINTER, but stores in destination instead of returning
+	def sinterstore(destination, *keys)
+		elements = sinter(*keys)
+		sadd(destination, *elements)
+	end
+
+	# Returns a list of the difference between the first set
+	# and subsequent sets
+	def sdiff(*keys)
+		sets = []
+		keys.each do |key|
+			sets << smembers(key)
+		end
+		diff = sets.shift
+		sets.each do |set|
+			diff -= set
+		end
+		return diff
+	end
+
+	# Similar to SDIFF, but stores in destination instead of returning
+	def sdiffstore(destination, *keys)
+		elements = sdiff(*keys)
+		sadd(destination, *elements)
+	end
+
+	# Move an item from one set to another
+	def smove(source, destination, member)
+		if !sismember(source, member)
+			return false
+		end
+		srem(source, member)
+		unless sismember(destination, member)
+			sadd(destination, member)
+		end
+		return true
+	end
+
+	# Returs a list of all unique items in the given sets
+	def sunion(*keys)
+	end
+
+	# Similar to SUNION, but stores in destination instead of returning
+	def sunionstore(destination, *keys)
+		elements = sunion(*keys)
+		sadd(destination, *elements)
+	end
+
+	# Returns a random element from the set
+	def srandmember(key)
+		smembers(key).sample
+	end
+
+	# Randomly remove and return an item from the set
+	def spop(key)
+		element = srandmember(key)
+		srem(key, element)
+		return element
+	end
+
 	# Determine if the given value is a member of the set at key
 	def sismember(key, member)
-		if @dict.has_key?(key)
-			if @dict[key].class == Array
-				return true unless @dict[key].index(member).nil?
-			else
-				raise STRC::Exception .new "ERR Operation against a key holding the wrong kind of value"
-			end
-		end
-		return false
+		set = smembers(key)
+		return !set.index(member).nil?
 	end
 
 	# Returns an array of members of the set
 	def smembers(key)
-		if @dict.has_key?(key)
-			if @dict[key].class == Array
-				return @dict[key]
+		if exists(key)
+			value = get(key)
+			if value.class == Array
+				return value
 			else
 				raise STRC::Exception .new "ERR Operation against a key holding the wrong kind of value"
 			end
@@ -70,14 +171,7 @@ class STRC
 
 	# Gets the length of a set
 	def scard(key)
-		if @dict.has_key?(key)
-			if @dict[key].class == Array
-				@dict[key].length
-			else
-				raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
-			end
-		else
-			return 0
-		end
+		set = smembers(key)
+		return set.length
 	end
 end

data/strc.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{strc}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Chris O'Neal"]
@@ -27,6 +27,8 @@ Gem::Specification.new do |s|
     "lib/strc.rb",
     "strc.gemspec",
     "test/helper.rb",
+    "test/test_basic_functions.rb",
+    "test/test_sets.rb",
     "test/test_strc.rb"
   ]
   s.homepage = %q{http://github.com/ctoneal/strc}
@@ -36,6 +38,8 @@ Gem::Specification.new do |s|
   s.summary = %q{Super Terrible Redis Clone}
   s.test_files = [
     "test/helper.rb",
+    "test/test_basic_functions.rb",
+    "test/test_sets.rb",
     "test/test_strc.rb"
   ]
 

data/test/test_basic_functions.rb

@@ -0,0 +1,119 @@
+require 'helper'
+
+class TestBasicFunctions < Test::Unit::TestCase
+	def setup
+		@test = STRC.new
+	end
+
+	context "set" do
+		should "be able to set the value of a new key" do
+			result = @test.set("test_key", 20)
+			assert_equal("OK", result)
+		end
+
+		should "be able to set the value of an existing key" do
+			@test.set("test_key", 20)
+			result = @test.set("test_key", 30)
+			assert_equal("OK", result)
+		end
+
+		should "be able to set different types as values" do
+			result = @test.set("test_key", "poop")
+			assert_equal("OK", result)
+		end
+
+		should "be able to set different types as keys" do
+			result = @test.set(15, "abcde")
+			assert_equal("OK", result)
+		end
+	end
+
+	context "get" do
+		should "be able to get the value of a key" do
+			@test.set("test_key", 15)
+			result = @test.get("test_key")
+			assert_equal(15, result)
+		end
+
+		should "return nil for nonexistant keys" do
+			result = @test.get("blah")
+			assert_nil(result)
+		end
+	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_sets.rb

@@ -0,0 +1,173 @@
+require 'helper'
+
+class TestSets < Test::Unit::TestCase
+	def setup
+		@test = STRC.new
+	end
+	context "sadd" do
+		should "create a new set" do
+			result = @test.sadd("test_key", "poop")
+			assert_equal(1, result)
+		end
+
+		should "be able to add multiple items" do
+			result = @test.sadd("test_key", "poop", "abc")
+			assert_equal(2, result)
+		end
+
+		should "be able to add to an existing set" do
+			@test.sadd("test_key", "poop")
+			result = @test.sadd("test_key", "blah")
+			assert_equal(1, result)
+		end
+
+		should "not be able to add to something not a set" do
+			@test.set("test_key", "blah")
+			assert_raise(STRC::Exception) { @test.sadd("test_key", "poop") }
+		end
+	end
+
+	context "sismember" do
+		should "return true if the set contains the object" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.sismember("test_key", "poop")
+			assert(result)
+		end
+
+		should "return false if the set does not contain the object" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.sismember("test_key", "xyz")
+			assert(!result)
+		end
+	end
+
+	context "scard" do
+		should "return the number of items in the set" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.scard("test_key")
+			assert_equal(3, result)
+		end
+
+		should "return 0 for nonexistant keys" do
+			result = @test.scard("blahblahblah")
+			assert_equal(0, result)
+		end
+	end
+
+	context "srem" do
+		should "remove an item from the set" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.srem("test_key", "poop")
+			assert(result)
+			assert_equal(2, @test.scard("test_key"))
+		end
+
+		should "not remove if the member isn't in the set" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.srem("test_key", "xyz")
+			assert(!result)
+			assert_equal(3, @test.scard("test_key"))
+		end
+	end
+
+	context "smembers" do
+		should "return an array of items" do
+			@test.sadd("test_key", "poop", "blah", "abc")
+			result = @test.smembers("test_key")
+			assert_equal(["poop", "blah", "abc"], result)
+		end
+
+		should "return an empty array for nonexistant keys" do
+			result = @test.smembers("aaaaaa")
+			assert_equal([], result)
+		end
+	end
+
+	context "sinter" do
+		should "return the intersection of two sets" do
+			@test.sadd("set1", "poop", "abc", "xyz")
+			@test.sadd("set2", "123", "456", "poop", "xyz")
+			result = @test.sinter("set1", "set2")
+			assert_equal(["poop", "xyz"], result)
+		end
+
+		should "be the same as smembers if passed one set" do
+			@test.sadd("set1", "poop", "abc", "xyz")
+			result = @test.sinter("set1")
+			assert_equal(["poop", "abc", "xyz"], result)
+		end
+	end
+
+	context "sinterstore" do
+		should "work like sinter, but store in destination" do
+			@test.sadd("set1", "poop", "abc", "xyz")
+			@test.sadd("set2", "123", "456", "poop", "xyz")
+			@test.sinterstore("new", "set1", "set2")
+			result = @test.smembers("new")
+			assert_equal(["poop", "xyz"], result)
+		end
+	end
+
+	context "sdiff" do
+		should "return items that are only in the first set" do
+			@test.sadd("set1", "a", "b", "c", "d")
+			@test.sadd("set2", "c")
+			@test.sadd("set3", "a", "c", "e")
+			result = @test.sdiff("set1", "set2", "set3")
+			assert_equal(["b", "d"], result)
+		end
+	end
+
+	context "sdiffstore" do
+		should "work like sdiff, but store in destination" do
+			@test.sadd("set1", "a", "b", "c", "d")
+			@test.sadd("set2", "c")
+			@test.sadd("set3", "a", "c", "e")
+			@test.sdiffstore("new", "set1", "set2", "set3")
+			result = @test.smembers("new")
+			assert_equal(["b", "d"], result)
+		end
+	end
+
+	context "smove" do
+		should "move an item from one set to another" do
+			@test.sadd("set1", "one" ,"two")
+			@test.sadd("set2", "three")
+			result = @test.smove("set1", "set2", "two")
+			assert(result)
+			members = @test.smembers("set1")
+			assert_equal(["one"], members)
+			members = @test.smembers("set2")
+			assert_equal(["three", "two"], members)
+		end
+	end
+
+	context "srandmember" do
+		should "return a random member of a set" do
+			@test.sadd("set1", "a", "b", "c", "d")
+			result = @test.sismember("set1", @test.srandmember("set1"))
+			assert(result)
+		end
+
+		should "return nil when key doesn't exist" do
+			result = @test.srandmember("poop")
+			assert_nil(result)
+		end
+	end
+
+	context "spop" do
+		should "return a random element from a set" do
+			items = ["a", "b", "c", "d"]
+			@test.sadd("set1", *items)
+			result = @test.spop("set1")
+			assert_not_nil(items.index(result))
+		end
+
+		should "remove the returned element from the set" do
+			items = ["a", "b", "c", "d"]
+			@test.sadd("set1", *items)
+			result = @test.spop("set1")
+			assert_equal(items.sort, (@test.smembers("set1") << result).sort)
+		end
+	end
+end

data/test/test_strc.rb

@@ -9,121 +9,4 @@ class TestStrc < Test::Unit::TestCase
 			assert_instance_of(STRC, @test)
 		end
 	end
-
-	context "setting" do
-		should "be able to set the value of a new key" do
-			result = @test.set("test_key", 20)
-			assert_equal("OK", result)
-		end
-
-		should "be able to set the value of an existing key" do
-			@test.set("test_key", 20)
-			result = @test.set("test_key", 30)
-			assert_equal("OK", result)
-		end
-
-		should "be able to set different types as values" do
-			result = @test.set("test_key", "poop")
-			assert_equal("OK", result)
-		end
-
-		should "be able to set different types as keys" do
-			result = @test.set(15, "abcde")
-			assert_equal("OK", result)
-		end
-	end
-
-	context "getting" do
-		should "be able to get the value of a key" do
-			@test.set("test_key", 15)
-			result = @test.get("test_key")
-			assert_equal(15, result)
-		end
-
-		should "return nil for nonexistant keys" do
-			result = @test.get("blah")
-			assert_nil(result)
-		end
-	end
-
-	context "sets" do
-		context "sadd" do
-			should "create a new set" do
-				result = @test.sadd("test_key", "poop")
-				assert_equal(1, result)
-			end
-
-			should "be able to add multiple items" do
-				result = @test.sadd("test_key", "poop", "abc")
-				assert_equal(2, result)
-			end
-
-			should "be able to add to an existing set" do
-				@test.sadd("test_key", "poop")
-				result = @test.sadd("test_key", "blah")
-				assert_equal(1, result)
-			end
-
-			should "not be able to add to something not a set" do
-				@test.set("test_key", "blah")
-				assert_raise(STRC::Exception) { @test.sadd("test_key", "poop") }
-			end
-		end
-
-		context "sismember" do
-			should "return true if the set contains the object" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.sismember("test_key", "poop")
-				assert(result)
-			end
-
-			should "return false if the set does not contain the object" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.sismember("test_key", "xyz")
-				assert(!result)
-			end
-		end
-
-		context "scard" do
-			should "return the number of items in the set" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.scard("test_key")
-				assert_equal(3, result)
-			end
-
-			should "return 0 for nonexistant keys" do
-				result = @test.scard("blahblahblah")
-				assert_equal(0, result)
-			end
-		end
-
-		context "srem" do
-			should "remove an item from the set" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.srem("test_key", "poop")
-				assert(result)
-				assert_equal(2, @test.scard("test_key"))
-			end
-
-			should "not remove if the member isn't in the set" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.srem("test_key", "xyz")
-				assert(!result)
-				assert_equal(3, @test.scard("test_key"))
-			end
-		end
-
-		context "smembers" do
-			should "return an array of items" do
-				@test.sadd("test_key", "poop", "blah", "abc")
-				result = @test.smembers("test_key")
-				assert_equal(["poop", "blah", "abc"], result)
-			end
-
-			should "return an empty array for nonexistant keys" do
-				result = @test.smembers("aaaaaa")
-				assert_equal([], result)
-			end
-		end
-	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: strc
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -14,7 +14,7 @@ default_executable:
 dependencies:
 - !ruby/object:Gem::Dependency
   name: shoulda
-  requirement: &9612756 !ruby/object:Gem::Requirement
+  requirement: &9687480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9612756
+  version_requirements: *9687480
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &9611472 !ruby/object:Gem::Requirement
+  requirement: &9686856 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *9611472
+  version_requirements: *9686856
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &9608676 !ruby/object:Gem::Requirement
+  requirement: &9685920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: 1.5.2
   type: :development
   prerelease: false
-  version_requirements: *9608676
+  version_requirements: *9685920
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &9608184 !ruby/object:Gem::Requirement
+  requirement: &9644496 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *9608184
+  version_requirements: *9644496
 description: STRC is a terrible Ruby clone of Redis
 email: ctoneal@gmail.com
 executables: []
@@ -74,6 +74,8 @@ files:
 - lib/strc.rb
 - strc.gemspec
 - test/helper.rb
+- test/test_basic_functions.rb
+- test/test_sets.rb
 - test/test_strc.rb
 has_rdoc: true
 homepage: http://github.com/ctoneal/strc
@@ -91,7 +93,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -949062349
+      hash: 876690863
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -106,4 +108,6 @@ specification_version: 3
 summary: Super Terrible Redis Clone
 test_files:
 - test/helper.rb
+- test/test_basic_functions.rb
+- test/test_sets.rb
 - test/test_strc.rb