Update Store and TTL implementation

Makefile

@@ -1,4 +1,5 @@
-test:	
+.PHONY: test
+test:
 	cargo test -- \
   		--nocapture \
   		--color=always

src/commands/decr.rs

@@ -14,6 +14,7 @@ pub struct Decr {
 
 impl Executable for Decr {
     fn exec(self, store: Store) -> Result<Frame, Error> {
+        let mut store = store.lock();
         let res = store.incr_by(&self.key, -1);
         match res {
             Ok(val) => Ok(Frame::Integer(val)),

src/commands/decrby.rs

@@ -15,6 +15,7 @@ pub struct DecrBy {
 
 impl Executable for DecrBy {
     fn exec(self, store: Store) -> Result<Frame, Error> {
+        let mut store = store.lock();
         let res = store.incr_by(&self.key, -self.decrement);
 
         match res {

src/commands/incr.rs

@@ -14,6 +14,7 @@ pub struct Incr {
 
 impl Executable for Incr {
     fn exec(self, store: Store) -> Result<Frame, Error> {
+        let mut store = store.lock();
         let res = store.incr_by(&self.key, 1);
         match res {
             Ok(val) => Ok(Frame::Integer(val)),

src/commands/incrby.rs

@@ -15,6 +15,7 @@ pub struct IncrBy {
 
 impl Executable for IncrBy {
     fn exec(self, store: Store) -> Result<Frame, Error> {
+        let mut store = store.lock();
         let res = store.incr_by(&self.key, self.increment);
         match res {
             Ok(value) => Ok(Frame::Integer(value)),

src/commands/incrbyfloat.rs

@@ -26,6 +26,7 @@ pub struct IncrByFloat {
 
 impl Executable for IncrByFloat {
     fn exec(self, store: Store) -> Result<Frame, Error> {
+        let mut store = store.lock();
         let res = store.incr_by(&self.key, self.increment);
         match res {
             Ok(res) => Ok(Frame::Simple(res.to_string())),

src/commands/mod.rs

@@ -343,11 +343,6 @@ impl CommandParser {
             }),
         }
     }
-
-    // TODO: !!!
-    fn has_more(&mut self) -> bool {
-        self.parts.clone().peekable().peek().is_some()
-    }
 }
 
 #[derive(Debug, ThisError, PartialEq)]

src/commands/set.rs

@@ -1,4 +1,5 @@
 use bytes::Bytes;
+use tokio::time::Duration;
 
 use crate::commands::executable::Executable;
 use crate::commands::{CommandParser, CommandParserError};
@@ -21,8 +22,10 @@ pub struct Set {
 
 #[derive(Debug, PartialEq)]
 pub enum SetBehavior {
-    Nx, // Only set the key if it does not already exist.
-    Xx, // Only set the key if it already exists.
+    /// Only set the key if it does not already exist.
+    Nx,
+    /// Only set the key if it already exists.
+    Xx,
 }
 
 #[derive(Debug, PartialEq)]
@@ -34,10 +37,20 @@ pub enum Ttl {
     KeepTtl, // Retain the time to live associated with the key.
 }
 
+impl Ttl {
+    pub fn duration(&self) -> Duration {
+        match self {
+            Ttl::Ex(seconds) => Duration::from_secs(*seconds),
+            Ttl::Px(millis) => Duration::from_millis(*millis),
+            // TODO: EXAT, PXAT and KeepTtl.
+            _ => Duration::from_secs(1),
+        }
+    }
+}
+
 impl Executable for Set {
     fn exec(self, store: Store) -> Result<Frame, Error> {
         let mut store = store.lock();
-
         let value = store.get(&self.key);
 
         match self.behavior {
@@ -46,7 +59,10 @@ impl Executable for Set {
             _ => {}
         }
 
-        store.set(self.key, self.value);
+        match self.ttl {
+            Some(ttl) => store.set_with_ttl(self.key, self.value, ttl.duration()),
+            None => store.set(self.key, self.value),
+        };
 
         let res = if self.get {
             value.map_or(Frame::NullBulkString, Frame::Bulk)
@@ -69,10 +85,16 @@ impl TryFrom<&mut CommandParser> for Set {
         let mut behavior = None;
         let mut get = false;
 
-        while parser.has_more() {
-            let opt = parser.next_string()?;
+        loop {
+            let option = match parser.next_string() {
+                Ok(option) => option,
+                Err(CommandParserError::EndOfStream) => {
+                    break;
+                }
+                Err(err) => return Err(err.into()),
+            };
 
-            match opt.as_str() {
+            match option.as_str() {
                 // TTL options
                 "EX" if ttl.is_none() => {
                     let val = parser.next_integer()?;
@@ -111,7 +133,7 @@ impl TryFrom<&mut CommandParser> for Set {
                 _ => {
                     return Err(CommandParserError::InvalidCommandArgument {
                         command: "SET".to_string(),
-                        argument: opt,
+                        argument: option,
                     }
                     .into())
                 }