Make Builder type private. Functionality is available in Plist::from_events.

2 files changed, 33 insertions, 30 deletions

diff --git a/src/builder.rs b/src/builder.rs
index 0b17f97..dcb3984 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -1,20 +1,19 @@
 use std::collections::BTreeMap;
-use std::io::{Read, Seek};
 
-use {ReadError, ReadResult, Plist, PlistEvent, EventReader};
+use {ReadError, ReadResult, Plist, PlistEvent};
 
-pub type BuilderResult<T> = Result<T, BuilderError>;
+pub type BuildResult<T> = Result<T, BuildError>;
 
 #[derive(Debug)]
-pub enum BuilderError {
+pub enum BuildError {
 	InvalidEvent,
 	UnsupportedDictionaryKey,
 	ReadError(ReadError)
 }
 
-impl From<ReadError> for BuilderError {
-	fn from(err: ReadError) -> BuilderError {
-		BuilderError::ReadError(err)
+impl From<ReadError> for BuildError {
+	fn from(err: ReadError) -> BuildError {
+		BuildError::ReadError(err)
 	}
 }
 
@@ -23,21 +22,15 @@ pub struct Builder<T> {
 	token: Option<PlistEvent>,
 }
 
-impl<R: Read+Seek> Builder<EventReader<R>> {
-	pub fn new(reader: R) -> Builder<EventReader<R>> {
-		Builder::from_event_stream(EventReader::new(reader))
-	}
-}
-
 impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
-	pub fn from_event_stream(stream: T) -> Builder<T> {
+	pub fn new(stream: T) -> Builder<T> {
 		Builder {
 			stream: stream,
 			token: None
 		}
 	}
 
-	pub fn build(mut self) -> BuilderResult<Plist> {
+	pub fn build(mut self) -> BuildResult<Plist> {
 		try!(self.bump());
 		if let Some(PlistEvent::StartPlist) = self.token {
 			try!(self.bump());
@@ -49,24 +42,24 @@ impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
 			None => (),
 			Some(PlistEvent::EndPlist) => try!(self.bump()),
 			// The stream should have finished
-			_ => return Err(BuilderError::InvalidEvent)
+			_ => return Err(BuildError::InvalidEvent)
 		};
 		Ok(plist)
 	}
 
-	fn bump(&mut self) -> BuilderResult<()> {
+	fn bump(&mut self) -> BuildResult<()> {
 		self.token = match self.stream.next() {
 			Some(Ok(token)) => Some(token),
-			Some(Err(err)) => return Err(BuilderError::ReadError(err)),
+			Some(Err(err)) => return Err(BuildError::ReadError(err)),
 			None => None,
 		};
 		Ok(())
 	}
 
-	fn build_value(&mut self) -> BuilderResult<Plist> {
+	fn build_value(&mut self) -> BuildResult<Plist> {
 		match self.token.take() {
-			Some(PlistEvent::StartPlist) => Err(BuilderError::InvalidEvent),
-			Some(PlistEvent::EndPlist) => Err(BuilderError::InvalidEvent),
+			Some(PlistEvent::StartPlist) => Err(BuildError::InvalidEvent),
+			Some(PlistEvent::EndPlist) => Err(BuildError::InvalidEvent),
 
 			Some(PlistEvent::StartArray(len)) => Ok(Plist::Array(try!(self.build_array(len)))),
 			Some(PlistEvent::StartDictionary(len)) => Ok(Plist::Dictionary(try!(self.build_dict(len)))),
@@ -78,15 +71,15 @@ impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
 			Some(PlistEvent::RealValue(f)) => Ok(Plist::Real(f)),
 			Some(PlistEvent::StringValue(s)) => Ok(Plist::String(s)),
 
-			Some(PlistEvent::EndArray) => Err(BuilderError::InvalidEvent),
-			Some(PlistEvent::EndDictionary) => Err(BuilderError::InvalidEvent),
+			Some(PlistEvent::EndArray) => Err(BuildError::InvalidEvent),
+			Some(PlistEvent::EndDictionary) => Err(BuildError::InvalidEvent),
 
 			// The stream should not have ended here
-			None => Err(BuilderError::InvalidEvent)
+			None => Err(BuildError::InvalidEvent)
 		}
 	}
 
-	fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>, BuilderError> {	
+	fn build_array(&mut self, len: Option<u64>) -> Result<Vec<Plist>, BuildError> {	
 		let mut values = match len {
 			Some(len) => Vec::with_capacity(len as usize),
 			None => Vec::new()
@@ -102,7 +95,7 @@ impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
 		}
 	}
 
-	fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Plist>, BuilderError> {
+	fn build_dict(&mut self, _len: Option<u64>) -> Result<BTreeMap<String, Plist>, BuildError> {
 		let mut values = BTreeMap::new();
 
 		loop {
@@ -115,7 +108,7 @@ impl<T:Iterator<Item=ReadResult<PlistEvent>>> Builder<T> {
 				},
 				_ => {
 					// Only string keys are supported in plists
-					return Err(BuilderError::UnsupportedDictionaryKey)
+					return Err(BuildError::UnsupportedDictionaryKey)
 				}
 			}
 		}
@@ -153,7 +146,7 @@ mod tests {
 			EndPlist,
 		];
 
-		let builder = Builder::from_event_stream(events.into_iter().map(|e| Ok(e)));
+		let builder = Builder::new(events.into_iter().map(|e| Ok(e)));
 		let plist = builder.build();
 
 		// Expected output
diff --git a/src/lib.rs b/src/lib.rs
index a5fa501..59524ae 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,8 +7,6 @@ pub mod binary;
 pub mod xml;
 mod builder;
 
-pub use builder::{Builder, BuilderError, BuilderResult};
-
 use chrono::{DateTime, UTC};
 use chrono::format::ParseError as ChronoParseError;
 use std::collections::BTreeMap;
@@ -31,6 +29,18 @@ use rustc_serialize::base64::{STANDARD, ToBase64};
 use rustc_serialize::json::Json as RustcJson;
 
 impl Plist {
+	pub fn from_events<T>(events: T) -> Result<Plist, ()>
+		where T: IntoIterator<Item = ReadResult<PlistEvent>>
+	{
+		let iter = events.into_iter();
+		let builder = builder::Builder::new(iter);
+
+		match builder.build() {
+			Ok(plist) => Ok(plist),
+			Err(_) => Err(())
+		}
+	}
+
 	pub fn into_events(self) -> Vec<PlistEvent> {
 		let mut events = Vec::new();
 		self.into_events_inner(&mut events);