Basic scan command implementation.

src/main/scala/com/redis/api/KeyOperations.scala

@@ -19,6 +19,9 @@ trait KeyOperations { this: RedisOps =>
   def keys(pattern: String = "*")(implicit timeout: Timeout) =
     clientRef.ask(Keys(pattern)).mapTo[Keys#Ret]
 
+	def scan(cursor:Long = 0, pattern: String = "", count: Long = 0)(implicit timeout: Timeout) =
+		clientRef.ask(Scan(cursor, pattern, count)).mapTo[Scan#Ret]
+
   // RANDOMKEY
   // return a randomly selected key from the currently selected DB.
   def randomkey(implicit timeout: Timeout) =

src/main/scala/com/redis/protocol/KeyCommands.scala

@@ -10,6 +10,13 @@ object KeyCommands {
     def params = pattern +: ANil
   }
 
+	case class Scan(cursor:Long = 0, pattern:String = "", count:Long = 0) extends RedisCommand[(Long, List[String])]("SCAN") {
+		def params = Seq( Seq(cursor.toString),
+			if(pattern != "") Seq("MATCH", pattern) else Nil,
+			if(count > 0) Seq("COUNT", count.toString) else Nil
+		).flatten.toArgs
+	}
+
   case object RandomKey extends RedisCommand[Option[String]]("RANDOMKEY") {
     def params = ANil
   }

src/main/scala/com/redis/serialization/PartialDeserializer.scala

@@ -110,6 +110,14 @@ private[serialization] trait CommandSpecificPD { this: LowPriorityPD =>
       }.toMap
     }
 
+	// special deserializer for SCAN
+	implicit def scanResultPD(implicit reader: Reader[String]):PartialDeserializer[(Long, List[String])] = {
+		new PrefixDeserializer[(Long, List[String])](Multi, (x: RawReply) => {
+			parseBulk(x)
+			(parseLong(x), listPD[String].apply(x))
+		})
+	}
+
   // special deserializer for EVAL(SHA)
   def ensureListPD[A](implicit reader: Reader[A]): PartialDeserializer[List[A]] =
     multiBulkPD[A, List].orElse(parsedOptionPD[A].andThen(_.toList))

src/test/scala/com/redis/api/KeyOperationsSpec.scala

@@ -24,12 +24,50 @@ class KeyOperationsSpec extends RedisSpecBase {
     it("should fetch keys with spaces") {
       val prepare = Seq(client.set("anshin 1", "debasish"), client.set("anshin 2", "maulindu"))
       val prepareRes = Future.sequence(prepare).futureValue
-
       val res = client.keys("anshin*")
       res.futureValue should have length (2)
     }
   }
 
+	describe("scan") {
+
+		val prepare = Seq(
+			client.set("key:1", "1"),
+			client.set("key:2", "2"),
+			client.set("key:3", "3"),
+			client.set("key:4", "4"),
+			client.set("key:5", "5"),
+			client.set("key:11", "11"),
+			client.set("key:22", "22"),
+			client.set("key:33", "33"),
+			client.set("key:44", "44"),
+			client.set("key:55", "55")
+		)
+
+		it("should collect all keys in keyspace") {
+			Future.sequence(prepare).futureValue
+			prepare.size equals iterateScan().size
+		}
+
+		it("should filter base on pattern") {
+			Future.sequence(prepare).futureValue
+			iterateScan(pattern = "*5*").size equals 2
+		}
+
+		def iterateScan(cursor:Long = 0, count:Long = 0, pattern:String = "") = {
+			var cursor = -1l
+			var keys = Seq[String]()
+			while(cursor != 0) {
+				val res = client.scan(cursor = if(cursor == -1) 0 else cursor, count = 2)
+				val w = res.futureValue
+				keys = keys ++ w._2
+				cursor = w._1
+			}
+			keys
+		}
+
+	}
+
   describe("randomkey") {
     it("should give") {
       val prepare = Seq(client.set("anshin-1", "debasish"), client.set("anshin-2", "maulindu"))