Add memory segment APIs

Author: daboross

Diff for: Cargo.toml

@@ -57,6 +57,8 @@ num = { version = "0.2", default-features = false }
 sync = ["tokio", "hyper-tls"]
 protocol-docs = []
 default = ["sync"]
+# enables tests which modify game state (temporarily, but still)
+destructive-tests = []
 
 [dev-dependencies]
 # .env parsing

Diff for: src/endpoints/memory_segment.rs

@@ -0,0 +1,61 @@
+//! Interpreting memory calls.
+use crate::{
+    data,
+    error::{ApiError, Result},
+    EndpointResult,
+};
+
+/// Call raw result.
+#[derive(serde_derive::Deserialize, Clone, Hash, Debug)]
+#[doc(hidden)]
+pub(crate) struct Response {
+    ok: i32,
+    data: String,
+}
+
+/// Memory segment retrieval result
+#[derive(Clone, Hash, Debug)]
+pub(crate) struct MemorySegment {
+    pub data: String,
+    /// Phantom data in order to allow adding any additional fields in the future.
+    _non_exhaustive: (),
+}
+
+impl EndpointResult for MemorySegment {
+    type RequestResult = Response;
+    type ErrorResult = data::ApiError;
+
+    fn from_raw(raw: Response) -> Result<Self> {
+        let Response { ok, data } = raw;
+
+        if ok != 1 {
+            return Err(ApiError::NotOk(ok).into());
+        }
+
+        Ok(MemorySegment {
+            data,
+            _non_exhaustive: (),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::EndpointResult;
+    use serde_json;
+
+    fn test_parse(json: serde_json::Value) {
+        let response = serde_json::from_value(json).unwrap();
+
+        let _ = MemorySegment::from_raw(response).unwrap();
+    }
+
+    #[test]
+    fn parse_sample() {
+        test_parse(json! ({
+            "ok": 1,
+            "data": "asdf"
+        }));
+    }
+}

Diff for: src/endpoints/mod.rs

@@ -4,12 +4,14 @@
 mod leaderboard;
 mod login;
 mod map_stats;
+mod memory_segment;
 mod my_info;
 mod recent_pvp;
 mod register;
 mod room_overview;
 mod room_status;
 mod room_terrain;
+mod set_memory_segment;
 mod shards;
 mod world_start_room;
 
@@ -19,5 +21,8 @@ pub mod template;
 
 pub use self::{
     leaderboard::*, login::*, map_stats::*, my_info::*, recent_pvp::*, register::*,
-    room_overview::*, room_status::*, room_terrain::*, shards::*, world_start_room::*,
+    room_overview::*, room_status::*, room_terrain::*, set_memory_segment::*, shards::*,
+    world_start_room::*,
 };
+
+pub(crate) use self::memory_segment::*;

Diff for: src/endpoints/set_memory_segment.rs

@@ -0,0 +1,70 @@
+//! Interpreting memory calls.
+use std::borrow::Cow;
+
+use crate::{
+    data,
+    error::{ApiError, Result},
+    EndpointResult,
+};
+
+/// Call raw result.
+#[derive(serde_derive::Deserialize, Clone, Hash, Debug)]
+#[doc(hidden)]
+pub(crate) struct Response {
+    ok: i32,
+}
+
+/// SetMemorySegment details
+#[derive(Serialize, Clone, Hash, Debug)]
+pub struct SetMemorySegmentArgs<'a> {
+    /// The segment to set.
+    pub segment: u32,
+    /// The shard to set it in (optional for private servers).
+    pub shard: Option<Cow<'a, str>>,
+    /// The data
+    pub data: Cow<'a, str>,
+}
+
+/// Memory segment set result
+#[derive(Clone, Hash, Debug)]
+pub(crate) struct SetMemorySegment {
+    /// Phantom data in order to allow adding any additional fields in the future.
+    _non_exhaustive: (),
+}
+
+impl EndpointResult for SetMemorySegment {
+    type RequestResult = Response;
+    type ErrorResult = data::ApiError;
+
+    fn from_raw(raw: Response) -> Result<Self> {
+        let Response { ok } = raw;
+
+        if ok != 1 {
+            return Err(ApiError::NotOk(ok).into());
+        }
+
+        Ok(SetMemorySegment {
+            _non_exhaustive: (),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::EndpointResult;
+    use serde_json;
+
+    fn test_parse(json: serde_json::Value) {
+        let response = serde_json::from_value(json).unwrap();
+
+        let _ = SetMemorySegment::from_raw(response).unwrap();
+    }
+
+    #[test]
+    fn parse_sample() {
+        test_parse(json! ({
+            "ok": 1,
+        }));
+    }
+}

Diff for: src/lib.rs

@@ -529,6 +529,56 @@ impl<C: hyper::client::connect::Connect + 'static> Api<C> {
             ])
             .send()
     }
+
+    /// Gets the player's memory segment on a given shard
+    pub fn memory_segment<'b, U>(
+        &self,
+        shard: Option<U>,
+        segment: u32,
+    ) -> Result<impl Future<Item = String, Error = Error>, NoToken>
+    where
+        U: Into<Cow<'b, str>>,
+    {
+        match shard {
+            Some(shard) => self
+                .get::<MemorySegment>("user/memory-segment")
+                .params(&[
+                    ("segment", segment.to_string()),
+                    ("shard", shard.into().into_owned()),
+                ])
+                .auth()
+                .send(),
+            None => self
+                .get::<MemorySegment>("user/memory-segment")
+                .params(&[("segment", segment.to_string())])
+                .auth()
+                .send(),
+        }
+        .map(|fut| fut.map(|res| res.data))
+    }
+
+    /// Sets the player's memory segment on a given shard
+    pub fn set_memory_segment<'b, U, V>(
+        &self,
+        shard: Option<U>,
+        segment: u32,
+        data: V,
+    ) -> Result<impl Future<Item = (), Error = Error>, NoToken>
+    where
+        U: Into<Cow<'b, str>>,
+        V: Into<Cow<'b, str>>,
+    {
+        let args = SetMemorySegmentArgs {
+            segment,
+            shard: shard.map(Into::into),
+            data: data.into(),
+        };
+
+        self.post("user/memory-segment", args)
+            .auth()
+            .send()
+            .map(|fut| fut.map(|_: SetMemorySegment| ()))
+    }
 }
 
 trait PartialRequestAuth<T> {

Diff for: src/sync.rs

@@ -341,4 +341,28 @@ impl<C: hyper::client::connect::Connect + 'static> SyncApi<C> {
             offset,
         )?)
     }
+
+    /// Gets a player's memory segment
+    pub fn memory_segment<'b, U>(&mut self, shard: Option<U>, segment: u32) -> Result<String, Error>
+    where
+        U: Into<Cow<'b, str>>,
+    {
+        self.runtime
+            .block_on(self.client.memory_segment(shard, segment)?)
+    }
+
+    /// Sets a player's memory segment
+    pub fn set_memory_segment<'b, U, V>(
+        &mut self,
+        shard: Option<U>,
+        segment: u32,
+        data: V,
+    ) -> Result<(), Error>
+    where
+        U: Into<Cow<'b, str>>,
+        V: Into<Cow<'b, str>>,
+    {
+        self.runtime
+            .block_on(self.client.set_memory_segment(shard, segment, data)?)
+    }
 }

Diff for: tests/authenticated_tests.rs

@@ -193,3 +193,20 @@ fn test_auth_leaderboard_limit_parameter_error() {
         }
     }
 }
+
+#[test]
+#[cfg(feature = "destructive-tests")]
+fn test_memory_segment() {
+    let mut api = logged_in();
+
+    let orig = api.memory_segment(Some("shard0"), 1).unwrap();
+
+    api.set_memory_segment(Some("shard0"), 1, "hi, you!")
+        .unwrap();
+
+    let retrieved = api.memory_segment(Some("shard0"), 1).unwrap();
+
+    api.set_memory_segment(Some("shard0"), 1, orig).unwrap();
+
+    assert_eq!(&retrieved, "hi, you!");
+}