get rid of some of the static lifetimes

8 files changed, 87 insertions, 79 deletions

diff --git a/src/call/account.rs b/src/call/account.rs
index 2cd89d5..6f60c8d 100644
--- a/src/call/account.rs
+++ b/src/call/account.rs
@@ -23,12 +23,12 @@ impl From<Login<'_>> for xmlrpc::Value {
 }
 
 impl Call for Login<'_> {
-    fn method_name(&self) -> &'static str {
-        "account.login"
+    fn method_name(&self) -> String {
+        String::from("account.login")
     }
 
-    fn expected(&self) -> &'static [i32] {
-        &[1000]
+    fn expected(&self) -> Vec<i32> {
+        vec![1000]
     }
 }
 
@@ -44,10 +44,10 @@ impl From<Logout> for xmlrpc::Value {
 }
 
 impl Call for Logout {
-    fn method_name(&self) -> &'static str {
-        "account.logout"
+    fn method_name(&self) -> String {
+        String::from("account.logout")
     }
-    fn expected(&self) -> &'static [i32] {
-        &[1500]
+    fn expected(&self) -> Vec<i32> {
+        vec![1500]
     }
 }
diff --git a/src/call/mod.rs b/src/call/mod.rs
index 6b44a16..f8fe0a2 100644
--- a/src/call/mod.rs
+++ b/src/call/mod.rs
@@ -1,7 +1,7 @@
 // A call to the API.
 pub trait Call: Clone + std::fmt::Debug + Into<xmlrpc::Value> {
-    fn method_name(&self) -> &'static str;
-    fn expected(&self) -> &'static [i32];
+    fn method_name(&self) -> String;
+    fn expected(&self) -> Vec<i32>;
 }
 
 pub mod account;
diff --git a/src/call/nameserver.rs b/src/call/nameserver.rs
index 884edab..c490a31 100644
--- a/src/call/nameserver.rs
+++ b/src/call/nameserver.rs
@@ -54,12 +54,12 @@ impl From<RecordInfo> for xmlrpc::Value {
 }
 
 impl Call for RecordInfo {
-    fn method_name(&self) -> &'static str {
-        "nameserver.info"
+    fn method_name(&self) -> String {
+        String::from("nameserver.info")
     }
 
-    fn expected(&self) -> &'static [i32] {
-        &[1000]
+    fn expected(&self) -> Vec<i32> {
+        vec![1000]
     }
 }
 
@@ -142,11 +142,11 @@ impl From<RecordUpdate> for xmlrpc::Value {
 }
 
 impl Call for RecordUpdate {
-    fn method_name(&self) -> &'static str {
-        "nameserver.updateRecord"
+    fn method_name(&self) -> String {
+        String::from("nameserver.updateRecord")
     }
 
-    fn expected(&self) -> &'static [i32] {
-        &[1000]
+    fn expected(&self) -> Vec<i32> {
+        vec![1000]
     }
 }
diff --git a/src/client.rs b/src/client.rs
index 60ae774..f7957cd 100644
--- a/src/client.rs
+++ b/src/client.rs
@@ -64,12 +64,13 @@ impl Client {
 
         let transport = self.inner.http.post::<Url>(self.inner.endpoint.into());
 
-        let request = xmlrpc::Request::new(call.method_name()).arg(call);
+        let binding = call.method_name();
+        let request = xmlrpc::Request::new(&binding).arg(call);
 
         let raw = request.call(transport)?;
         match raw {
             xmlrpc::Value::Struct(map) => {
-                let code = map.get("code").ok_or(Error::Inexistent("code"))?;
+                let code = map.get("code").ok_or(Error::Inexistent("code".into()))?;
 
                 match code {
                     xmlrpc::Value::Int(code) => {
@@ -82,13 +83,17 @@ impl Client {
                                     status: *code,
                                     data: response.clone(),
                                 }),
-                                _ => Err(Error::Type("resData", "Struct", data.clone())),
+                                _ => Err(Error::Type(
+                                    "resData".into(),
+                                    "Struct".into(),
+                                    data.clone(),
+                                )),
                             }
                         } else {
                             Err(Error::BadStatus(expected, *code))
                         }
                     }
-                    _ => Err(Error::Type("code", "Int", code.clone())),
+                    _ => Err(Error::Type("code".into(), "Int".into(), code.clone())),
                 }
             }
             _ => Err(Error::BadResponse(raw.clone())),
diff --git a/src/common/mod.rs b/src/common/mod.rs
index ee54eed..c9ca264 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -4,71 +4,74 @@ use std::collections::BTreeMap;
 
 use iso8601::DateTime;
 
-pub(crate) fn get_str(map: &BTreeMap<String, xmlrpc::Value>, key: &'static str) -> Result<String> {
+pub(crate) fn get_str(map: &BTreeMap<String, xmlrpc::Value>, key: String) -> Result<String> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_str()
-        .ok_or_else(|| Error::Type(key, "String", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| Error::Type(key.clone(), "String".into(), map.get(&key).unwrap().clone()))?;
 
     Ok(value.to_owned())
 }
 
-pub(crate) fn get_i32(map: &BTreeMap<String, xmlrpc::Value>, key: &'static str) -> Result<i32> {
+pub(crate) fn get_i32(map: &BTreeMap<String, xmlrpc::Value>, key: String) -> Result<i32> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_i32()
-        .ok_or_else(|| Error::Type(key, "Int", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| Error::Type(key.clone(), "Int".into(), map.get(&key).unwrap().clone()))?;
 
     Ok(value)
 }
 
-pub(crate) fn get_bool(map: &BTreeMap<String, xmlrpc::Value>, key: &'static str) -> Result<bool> {
+pub(crate) fn get_bool(map: &BTreeMap<String, xmlrpc::Value>, key: String) -> Result<bool> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_bool()
-        .ok_or_else(|| Error::Type(key, "Bool", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| Error::Type(key.clone(), "Bool".into(), map.get(&key).unwrap().clone()))?;
 
     Ok(value)
 }
 
-pub(crate) fn get_datetime(
-    map: &BTreeMap<String, xmlrpc::Value>,
-    key: &'static str,
-) -> Result<DateTime> {
+pub(crate) fn get_datetime(map: &BTreeMap<String, xmlrpc::Value>, key: String) -> Result<DateTime> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_datetime()
-        .ok_or_else(|| Error::Type(key, "DateTime", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| {
+            Error::Type(
+                key.clone(),
+                "DateTime".into(),
+                map.get(&key).unwrap().clone(),
+            )
+        })?;
 
     Ok(value)
 }
 
 pub(crate) fn get_array(
     map: &BTreeMap<String, xmlrpc::Value>,
-    key: &'static str,
+    key: String,
 ) -> Result<Vec<xmlrpc::Value>> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_array()
-        .ok_or_else(|| Error::Type(key, "Array", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| Error::Type(key.clone(), "Array".into(), map.get(&key).unwrap().clone()))?;
 
     Ok(value.to_vec())
 }
 
 pub(crate) fn get_map(
     map: &BTreeMap<String, xmlrpc::Value>,
-    key: &'static str,
+    key: String,
 ) -> Result<BTreeMap<String, xmlrpc::Value>> {
     let value = map
-        .get(key)
-        .ok_or(Error::Inexistent(key))?
+        .get(&key)
+        .ok_or(Error::Inexistent(key.clone()))?
         .as_struct()
-        .ok_or_else(|| Error::Type(key, "Struct", map.get(key).unwrap().clone()))?;
+        .ok_or_else(|| Error::Type(key.clone(), "Struct".into(), map.get(&key).unwrap().clone()))?;
 
     Ok(value.to_owned())
 }
diff --git a/src/common/nameserver.rs b/src/common/nameserver.rs
index 9b8c797..706ae73 100644
--- a/src/common/nameserver.rs
+++ b/src/common/nameserver.rs
@@ -97,7 +97,7 @@ impl TryFrom<String> for RecordType {
             "TXT" => Ok(Self::Txt),
             "URI" => Ok(Self::Uri),
             "URL" => Ok(Self::Url),
-            _ => Err(Error::BadVariant("RecordType", s)),
+            _ => Err(Error::BadVariant("RecordType".into(), s)),
         }
     }
 }
@@ -124,7 +124,7 @@ impl TryFrom<String> for DomainType {
         match s.as_str() {
             "MASTER" => Ok(Self::Master),
             "SLAVE" => Ok(Self::Slave),
-            _ => Err(Error::BadVariant("DomainType", s)),
+            _ => Err(Error::BadVariant("DomainType".into(), s)),
         }
     }
 }
@@ -140,8 +140,8 @@ impl TryFrom<BTreeMap<String, xmlrpc::Value>> for SlaveDns {
     type Error = Error;
     fn try_from(map: BTreeMap<String, xmlrpc::Value>) -> Result<Self> {
         Ok(Self {
-            hostname: get_str(&map, "name")?,
-            address: get_str(&map, "ip")?,
+            hostname: get_str(&map, "name".into())?,
+            address: get_str(&map, "ip".into())?,
         })
     }
 }
@@ -171,7 +171,7 @@ impl TryFrom<String> for UrlRdrType {
             "HEADER301" => Ok(Self::Permanent),
             "HEADER302" => Ok(Self::Temporary),
             "FRAME" => Ok(Self::Frame),
-            _ => Err(Error::BadVariant("UrlRdrType", s)),
+            _ => Err(Error::BadVariant("UrlRdrType".into(), s)),
         }
     }
 }
diff --git a/src/error/mod.rs b/src/error/mod.rs
index 218997f..b8a8c16 100644
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@@ -6,11 +6,11 @@ pub enum Error {
     ParseUrl(url::ParseError),
     Reqwest(reqwest::Error),
     XmlRpc(xmlrpc::Error),
-    Inexistent(&'static str),
-    Type(&'static str, &'static str, xmlrpc::Value),
+    Inexistent(String),
+    Type(String, String, xmlrpc::Value),
     BadResponse(xmlrpc::Value),
-    BadStatus(&'static [i32], i32),
-    BadVariant(&'static str, String),
+    BadStatus(Vec<i32>, i32),
+    BadVariant(String, String),
 }
 
 impl std::error::Error for Error {}
diff --git a/src/response/nameserver.rs b/src/response/nameserver.rs
index 24e341e..6ac330b 100644
--- a/src/response/nameserver.rs
+++ b/src/response/nameserver.rs
@@ -27,26 +27,26 @@ impl TryFrom<xmlrpc::Value> for Record {
     fn try_from(v: xmlrpc::Value) -> Result<Self> {
         if let xmlrpc::Value::Struct(map) = v {
             let record = Self {
-                id: get_i32(&map, "id")?,
-                name: get_str(&map, "name")?,
-                record_type: get_str(&map, "type")?.try_into()?,
-                content: get_str(&map, "content")?,
-                ttl: get_i32(&map, "ttl")?,
-                priority: get_i32(&map, "prio")?,
-                url_rdr_type: match get_str(&map, "urlRedirectType").ok() {
+                id: get_i32(&map, "id".into())?,
+                name: get_str(&map, "name".into())?,
+                record_type: get_str(&map, "type".into())?.try_into()?,
+                content: get_str(&map, "content".into())?,
+                ttl: get_i32(&map, "ttl".into())?,
+                priority: get_i32(&map, "prio".into())?,
+                url_rdr_type: match get_str(&map, "urlRedirectType".into()).ok() {
                     Some(url_rdr_type) => url_rdr_type.try_into().ok(),
                     None => None,
                 },
-                url_rdr_title: get_str(&map, "urlRedirectTitle").ok(),
-                url_rdr_desc: get_str(&map, "urlRedirectDescription").ok(),
-                url_rdr_keywords: get_str(&map, "urlRedirectKeywords").ok(),
-                url_rdr_favicon: get_str(&map, "urlRedirectFavIcon").ok(),
-                url_append: get_bool(&map, "urlAppend").ok(),
+                url_rdr_title: get_str(&map, "urlRedirectTitle".into()).ok(),
+                url_rdr_desc: get_str(&map, "urlRedirectDescription".into()).ok(),
+                url_rdr_keywords: get_str(&map, "urlRedirectKeywords".into()).ok(),
+                url_rdr_favicon: get_str(&map, "urlRedirectFavIcon".into()).ok(),
+                url_append: get_bool(&map, "urlAppend".into()).ok(),
             };
 
             Ok(record)
         } else {
-            Err(Error::Type("record", "Struct", v))
+            Err(Error::Type("record".into(), "Struct".into(), v))
         }
     }
 }
@@ -68,20 +68,20 @@ impl TryFrom<Response> for RecordInfo {
     type Error = Error;
     fn try_from(resp: Response) -> Result<Self> {
         let info = Self {
-            domain_id: get_i32(&resp.data, "roId").ok(),
-            domain_name: get_str(&resp.data, "domain").ok(),
-            domain_type: match get_str(&resp.data, "type").ok() {
+            domain_id: get_i32(&resp.data, "roId".into()).ok(),
+            domain_name: get_str(&resp.data, "domain".into()).ok(),
+            domain_type: match get_str(&resp.data, "type".into()).ok() {
                 Some(domain_type) => domain_type.try_into().ok(),
                 None => None,
             },
-            master_address: get_str(&resp.data, "masterIp").ok(),
-            last_zone_check: get_datetime(&resp.data, "lastZoneCheck").ok(),
-            slave_dns: match get_map(&resp.data, "slaveDns").ok() {
+            master_address: get_str(&resp.data, "masterIp".into()).ok(),
+            last_zone_check: { get_datetime(&resp.data, "lastZoneCheck".into()).ok() },
+            slave_dns: match get_map(&resp.data, "slaveDns".into()).ok() {
                 Some(slave_dns) => slave_dns.try_into().ok(),
                 None => None,
             },
-            soa_serial: get_str(&resp.data, "SOAserial").ok(),
-            records: match get_array(&resp.data, "record").ok() {
+            soa_serial: get_str(&resp.data, "SOAserial".into()).ok(),
+            records: match get_array(&resp.data, "record".into()).ok() {
                 Some(records) => Some(
                     records
                         .iter()