Implement FromStr for JsonApiDocument and Resource

Author: nubis

src/api.rs

@@ -1,5 +1,8 @@
 use serde_json;
 use std::collections::HashMap;
+use errors::*;
+use std::str::FromStr;
+use std;
 
 /// Permitted JSON-API values (all JSON Values)
 pub type JsonApiValue = serde_json::Value;
@@ -247,11 +250,16 @@ impl JsonApiDocument {
         }
 
     }
+}
+
+impl FromStr for JsonApiDocument {
+    type Err = Error;
 
     /// Instantiate from string
     ///
     /// ```
     /// use jsonapi::api::JsonApiDocument;
+    /// use std::str::FromStr;
     ///
     /// let serialized = r#"{
     ///   "data" : [
@@ -263,35 +271,12 @@ impl JsonApiDocument {
     /// let doc = JsonApiDocument::from_str(&serialized);
     /// assert_eq!(doc.is_ok(), true);
     /// ```
-    pub fn from_str(s: &str) -> Result<Self, serde_json::Error> {
-        serde_json::from_str(s)
+    fn from_str(s: &str) -> Result<Self> {
+        serde_json::from_str(s).chain_err(|| "Error parsing Document")
     }
 }
 
 impl Resource {
-    /// Instantiate from string
-    ///
-    /// ```
-    /// use jsonapi::api::Resource;
-    ///
-    /// let serialized = r#"{
-    ///   "id":"1",
-    ///   "type":"post",
-    ///   "attributes":{
-    ///     "title": "Rails is Omakase",
-    ///     "likes": 250
-    ///   },
-    ///   "relationships":{},
-    ///   "links" :{}
-    /// }"#;
-    ///
-    /// let data = Resource::from_str(&serialized);
-    /// assert_eq!(data.is_ok(), true);
-    /// ```
-    pub fn from_str(s: &str) -> Result<Self, serde_json::Error> {
-        serde_json::from_str(s)
-    }
-
     pub fn get_relationship(&self, name: &str) -> Option<&Relationship> {
         match self.relationships {
             None => None,
@@ -308,6 +293,7 @@ impl Resource {
     ///
     /// ```
     /// use jsonapi::api::Resource;
+    /// use std::str::FromStr;
     ///
     /// let serialized = r#"{
     ///   "id":"1",
@@ -343,7 +329,7 @@ impl Resource {
         }
     }
 
-    pub fn diff(&self, other: Resource) -> Result<PatchSet, DiffPatchError> {
+    pub fn diff(&self, other: Resource) -> std::result::Result<PatchSet, DiffPatchError> {
         if self._type != other._type {
             Err(DiffPatchError::IncompatibleTypes(self._type.clone(), other._type.clone()))
         } else {
@@ -391,7 +377,7 @@ impl Resource {
         }
     }
 
-    pub fn patch(&mut self, patchset: PatchSet) -> Result<Resource, DiffPatchError> {
+    pub fn patch(&mut self, patchset: PatchSet) -> Result<Resource> {
         let mut res = self.clone();
         for patch in &patchset.patches {
             res.attributes.insert(patch.subject.clone(), patch.next.clone());
@@ -400,16 +386,45 @@ impl Resource {
     }
 }
 
+impl FromStr for Resource {
+    type Err = Error;
+
+    /// Instantiate from string
+    ///
+    /// ```
+    /// use jsonapi::api::Resource;
+    /// use std::str::FromStr;
+    ///
+    /// let serialized = r#"{
+    ///   "id":"1",
+    ///   "type":"post",
+    ///   "attributes":{
+    ///     "title": "Rails is Omakase",
+    ///     "likes": 250
+    ///   },
+    ///   "relationships":{},
+    ///   "links" :{}
+    /// }"#;
+    ///
+    /// let data = Resource::from_str(&serialized);
+    /// assert_eq!(data.is_ok(), true);
+    /// ```
+    fn from_str(s: &str) -> Result<Self> {
+        serde_json::from_str(s).chain_err(|| "Error parsing resource" )
+    }
+}
+
+
 impl Relationship {
-    pub fn as_id(&self) -> Result<Option<&JsonApiId>, RelationshipAssumptionError> {
+    pub fn as_id(&self) -> std::result::Result<Option<&JsonApiId>, RelationshipAssumptionError> {
         match self.data {
             IdentifierData::None => Ok(None),
             IdentifierData::Multiple(_) => Err(RelationshipAssumptionError::RelationshipIsAList),
             IdentifierData::Single(ref data) => Ok(Some(&data.id)),
         }
     }
 
-    pub fn as_ids(&self) -> Result<Option<JsonApiIds>, RelationshipAssumptionError> {
+    pub fn as_ids(&self) -> std::result::Result<Option<JsonApiIds>, RelationshipAssumptionError> {
         match self.data {
             IdentifierData::None => Ok(None),
             IdentifierData::Single(_) => Err(RelationshipAssumptionError::RelationshipIsNotAList),

src/model.rs

@@ -4,25 +4,28 @@ use errors::*;
 use serde::{Deserialize, Serialize};
 use serde_json::{from_value, to_value, Value, Map};
 
-/* A trait for any struct that can be converted from/into a Resource.
- * The only requirement is that your struct has a field that implements
- * `ToString` and can be used as an ID. (not necesarilly called ID though).
- * You shouldn't be implementing JsonApiModel manually, look at the
- * `jsonapi_model` macro instead.
- */
+/// A trait for any struct that can be converted from/into a Resource.
+/// The only requirement is that your struct has an 'id: String' field.
+/// You shouldn't be implementing JsonApiModel manually, look at the
+/// `jsonapi_model!` macro instead.
 pub trait JsonApiModel: Serialize
     where for<'de> Self: Deserialize<'de>
 {
+    #[doc(hidden)]
     fn jsonapi_type(&self) -> String;
+    #[doc(hidden)]
     fn jsonapi_id(&self) -> String;
+    #[doc(hidden)]
     fn relationship_fields() -> Option<&'static [&'static str]>;
+    #[doc(hidden)]
     fn build_relationships(&self) -> Option<Relationships>;
+    #[doc(hidden)]
     fn build_included(&self) -> Option<Resources>;
 
     fn from_jsonapi_resource(resource: &Resource, included: &Option<Resources>)
         -> Result<Self> 
     {
-        Self::from_serializable(Self::resource_to_attrs(&resource, &included))
+        Self::from_serializable(Self::resource_to_attrs(resource, included))
     }
 
     fn from_jsonapi_document(doc: &JsonApiDocument) -> Result<Self> {
@@ -31,11 +34,11 @@ pub trait JsonApiModel: Serialize
                 match *primary_data {
                     PrimaryData::None => bail!("Document had no data"),
                     PrimaryData::Single(ref resource) =>
-                        Self::from_jsonapi_resource(&resource, &doc.included),
+                        Self::from_jsonapi_resource(resource, &doc.included),
                     PrimaryData::Multiple(ref resources) => {
                         let all: Vec<ResourceAttributes> = resources
                             .iter()
-                            .map(|r| Self::resource_to_attrs(&r, &doc.included))
+                            .map(|r| Self::resource_to_attrs(r, &doc.included))
                             .collect();
                         Self::from_serializable(all)
                     }
@@ -76,14 +79,16 @@ pub trait JsonApiModel: Serialize
     }
 
 
+    #[doc(hidden)]
     fn build_has_one<M: JsonApiModel>(model: &M) -> Relationship {
         Relationship{
             data: IdentifierData::Single(model.as_resource_identifier()),
             links: None
         }
     }
 
-    fn build_has_many<M: JsonApiModel>(models: &Vec<M>) -> Relationship {
+    #[doc(hidden)]
+    fn build_has_many<M: JsonApiModel>(models: &[M]) -> Relationship {
         Relationship{
             data: IdentifierData::Multiple(
                 models.iter().map(|m| m.as_resource_identifier()).collect()
@@ -92,6 +97,7 @@ pub trait JsonApiModel: Serialize
         }
     }
 
+    #[doc(hidden)]
     fn as_resource_identifier(&self) -> ResourceIdentifier {
         ResourceIdentifier {
             _type: self.jsonapi_type(),
@@ -103,17 +109,19 @@ pub trait JsonApiModel: Serialize
      * before calling this, so there's no need to ignore it like we do
      * with the attributes that correspond with relationships.
      * */
+    #[doc(hidden)]
     fn extract_attributes(attrs: &Map<String, Value>) -> ResourceAttributes {
         attrs.iter().filter(|&(key, _)|{
-            if let Some(ref fields) = Self::relationship_fields(){
+            if let Some(fields) = Self::relationship_fields(){
                 if fields.contains(&key.as_str()) {
                     return false;
                 }
             }
-            return true;
+            true
         }).map(|(k,v)|{ (k.clone(), v.clone()) }).collect()
     }
 
+    #[doc(hidden)]
     fn to_resources(&self) -> Resources {
         let (me, maybe_others) = self.to_jsonapi_resource();
         let mut flattened = vec![me];
@@ -123,17 +131,19 @@ pub trait JsonApiModel: Serialize
         flattened
     }
 
-    fn lookup<'a>(needle: &ResourceIdentifier, haystack: &'a Resources)
+    #[doc(hidden)]
+    fn lookup<'a>(needle: &ResourceIdentifier, haystack: &'a [Resource])
         -> Option<&'a Resource> 
     {
         for resource in haystack {
             if resource._type == needle._type && resource.id == needle.id {
-                return Some(&resource)
+                return Some(resource)
             }
         }
         None
     }
 
+    #[doc(hidden)]
     fn resource_to_attrs(resource: &Resource, included: &Option<Resources>)
         -> ResourceAttributes 
     {
@@ -148,15 +158,15 @@ pub trait JsonApiModel: Serialize
                         IdentifierData::None => Value::Null,
                         IdentifierData::Single(ref identifier) => {
                             let found = Self::lookup(identifier, inc)
-                                .map(|r| Self::resource_to_attrs(r, &included) );
+                                .map(|r| Self::resource_to_attrs(r, included) );
                             to_value(found)
                                 .expect("Casting Single relation to value")
                         },
                         IdentifierData::Multiple(ref identifiers) => {
                             let found: Vec<Option<ResourceAttributes>> =
                                 identifiers.iter().map(|id|{
                                     Self::lookup(id, inc).map(|r|{
-                                        Self::resource_to_attrs(r, &included)
+                                        Self::resource_to_attrs(r, included)
                                     })
                                 }).collect();
                             to_value(found)
@@ -171,6 +181,7 @@ pub trait JsonApiModel: Serialize
         new_attrs
     }
 
+    #[doc(hidden)]
     fn from_serializable<S: Serialize>(s: S) -> Result<Self> {
         from_value(to_value(s).unwrap())
             .chain_err(|| "Error casting via serde_json")