Include the child tag name into 'InvalidChildElement' error.

src/errors.rs

@@ -5,9 +5,9 @@ error_chain!{
     errors {
         /// InvalidChildElement signifies when an element has a child that isn't
         /// valid per the GPX spec.
-        InvalidChildElement(parent: &'static str) {
+        InvalidChildElement(child: String, parent: &'static str) {
             description("invalid child element")
-            display("invalid child element in {}", String::from(*parent))
+            display("invalid child element '{}' in {}", child, String::from(*parent))
         }
 
         /// InvalidElementLacksAttribute signifies when an element is missing a

src/parser/email.rs

@@ -40,7 +40,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<String> {
 
                         email = Some(format!("{id}@{domain}", id = id, domain = domain));
                     }
-                    _ => Err(Error::from(ErrorKind::InvalidChildElement("email")))?,
+                    child => Err(Error::from(ErrorKind::InvalidChildElement(
+                        String::from(child),
+                        "email",
+                    )))?,
                 }
             }
 
@@ -117,7 +120,7 @@ mod tests {
         let err = consume!("<email id=\"id\" domain=\"domain\"><child /></email>").unwrap_err();
 
         assert_eq!(err.description(), "invalid child element");
-        assert_eq!(err.to_string(), "invalid child element in email");
+        assert_eq!(err.to_string(), "invalid child element 'child' in email");
     }
 
     #[test]

src/parser/gpx.rs

@@ -37,7 +37,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Gpx> {
                             "trk" => Ok(ParseEvent::StartTrack),
                             "wpt" => Ok(ParseEvent::StartWaypoint),
                             "gpx" => Ok(ParseEvent::Ignore),
-                            _ => Err(Error::from(ErrorKind::InvalidChildElement("gpx")))?,
+                            child => Err(Error::from(ErrorKind::InvalidChildElement(
+                                String::from(child),
+                                "gpx",
+                            )))?,
                         }
                     }
 

src/parser/link.rs

@@ -35,7 +35,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Link> {
 
                         link.href = attr.value;
                     }
-                    _ => Err(Error::from(ErrorKind::InvalidChildElement("link")))?,
+                    child => Err(Error::from(ErrorKind::InvalidChildElement(
+                        String::from(child),
+                        "link",
+                    )))?,
                 }
             }
 

src/parser/metadata.rs

@@ -43,7 +43,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Metadata> {
                             "keywords" => Ok(ParseEvent::StartKeywords),
                             "time" => Ok(ParseEvent::StartTime),
                             "link" => Ok(ParseEvent::StartLink),
-                            _ => Err(Error::from(ErrorKind::InvalidChildElement("metadata")))?,
+                            child => Err(Error::from(ErrorKind::InvalidChildElement(
+                                String::from(child),
+                                "metadata",
+                            )))?,
                         }
                     }
 

src/parser/person.rs

@@ -37,7 +37,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Person> {
                             "link" => Ok(ParseEvent::StartLink),
                             "person" => Ok(ParseEvent::Ignore),
                             "author" => Ok(ParseEvent::Ignore),
-                            _ => Err(Error::from(ErrorKind::InvalidChildElement("person"))),
+                            child => Err(Error::from(ErrorKind::InvalidChildElement(
+                                String::from(child),
+                                "person",
+                            ))),
                         }
                     }
 

src/parser/track.rs

@@ -25,7 +25,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Track> {
                 "src" => track.source = Some(string::consume(reader)?),
                 "type" => track._type = Some(string::consume(reader)?),
                 "trkseg" => track.segments.push(tracksegment::consume(reader)?),
-                _ => Err(Error::from(ErrorKind::InvalidChildElement("track")))?,
+                child => Err(Error::from(ErrorKind::InvalidChildElement(
+                    String::from(child),
+                    "track",
+                )))?,
             },
 
             XmlEvent::EndElement { .. } => {

src/parser/tracksegment.rs

@@ -32,7 +32,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<TrackSegment
                         match name.local_name.as_ref() {
                             "trkseg" => Ok(TrackSegmentEvent::StartTrkSeg),
                             "trkpt" => Ok(TrackSegmentEvent::StartTrkPt),
-                            _ => Err(Error::from(ErrorKind::InvalidChildElement("tracksegment"))),
+                            child => Err(Error::from(ErrorKind::InvalidChildElement(
+                                String::from(child),
+                                "tracksegment",
+                            ))),
                         }
                     }
 

src/parser/waypoint.rs

@@ -123,7 +123,10 @@ pub fn consume<R: Read>(reader: &mut Peekable<Events<R>>) -> Result<Waypoint> {
 
                     // Finally the GPX 1.1 extensions
                     "extensions" => extensions::consume(reader)?,
-                    _ => Err(Error::from(ErrorKind::InvalidChildElement("waypoint")))?,
+                    child => Err(Error::from(ErrorKind::InvalidChildElement(
+                        String::from(child),
+                        "waypoint",
+                    )))?,
                 }
             }