Implement Show for stuff

Author: sfackler

src/error.rs

@@ -356,7 +356,7 @@ make_errors! {
 }
 
 /// Reasons a new Postgres connection could fail
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
 pub enum ConnectError {
     /// The provided URL could not be parsed
     InvalidUrl(String),
@@ -431,7 +431,7 @@ impl error::FromError<SslError> for ConnectError {
     }
 }
 
-impl fmt::Show for ConnectError {
+impl fmt::String for ConnectError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             ConnectError::InvalidUrl(ref err) => write!(fmt, "Invalid URL: {}", err),
@@ -454,7 +454,7 @@ impl fmt::Show for ConnectError {
 }
 
 /// Represents the position of an error in a query
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
 pub enum ErrorPosition {
     /// A position in the original query
     Normal(usize),
@@ -468,7 +468,7 @@ pub enum ErrorPosition {
 }
 
 /// Encapsulates a Postgres error or notice.
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
 pub struct DbError {
     /// The field contents are ERROR, FATAL, or PANIC (in an error message),
     /// or WARNING, NOTICE, DEBUG, INFO, or LOG (in a notice message), or a
@@ -572,7 +572,7 @@ impl DbError {
     }
 }
 
-impl fmt::Show for DbError {
+impl fmt::String for DbError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{}: {}", self.severity, self.message)
     }
@@ -589,7 +589,7 @@ impl error::Error for DbError {
 }
 
 /// An error encountered when communicating with the Postgres server
-#[derive(Clone, PartialEq, Eq)]
+#[derive(Clone, PartialEq, Eq, Show)]
 pub enum Error {
     /// An error reported by the Postgres server
     DbError(DbError),
@@ -623,7 +623,7 @@ pub enum Error {
     BadData,
 }
 
-impl fmt::Show for Error {
+impl fmt::String for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Error::DbError(ref err) => err.fmt(fmt),

src/lib.rs

@@ -105,7 +105,7 @@ const TYPENAME_QUERY: &'static str = "t";
 pub type Result<T> = result::Result<T, Error>;
 
 /// Specifies the target server to connect to.
-#[derive(Clone)]
+#[derive(Clone, Show)]
 pub enum ConnectTarget {
     /// Connect via TCP to the specified host.
     Tcp(String),
@@ -114,7 +114,7 @@ pub enum ConnectTarget {
 }
 
 /// Authentication information
-#[derive(Clone)]
+#[derive(Clone, Show)]
 pub struct UserInfo {
     /// The username
     pub user: String,
@@ -123,7 +123,7 @@ pub struct UserInfo {
 }
 
 /// Information necessary to open a new connection to a Postgres server.
-#[derive(Clone)]
+#[derive(Clone, Show)]
 pub struct ConnectParams {
     /// The target server
     pub target: ConnectTarget,
@@ -205,7 +205,7 @@ pub trait NoticeHandler: Send {
 /// A notice handler which logs at the `info` level.
 ///
 /// This is the default handler used by a `Connection`.
-#[derive(Copy)]
+#[derive(Copy, Show)]
 pub struct DefaultNoticeHandler;
 
 impl NoticeHandler for DefaultNoticeHandler {
@@ -215,6 +215,7 @@ impl NoticeHandler for DefaultNoticeHandler {
 }
 
 /// An asynchronous notification
+#[derive(Clone, Show)]
 pub struct Notification {
     /// The process ID of the notifying backend process
     pub pid: u32,
@@ -229,6 +230,12 @@ pub struct Notifications<'conn> {
     conn: &'conn Connection
 }
 
+impl<'a> fmt::Show for Notifications<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Notifications")
+    }
+}
+
 impl<'conn> Iterator for Notifications<'conn> {
     type Item = Notification;
 
@@ -326,7 +333,7 @@ impl<'conn> Notifications<'conn> {
 }
 
 /// Contains information necessary to cancel queries for a session
-#[derive(Copy)]
+#[derive(Copy, Clone, Show)]
 pub struct CancelData {
     /// The process ID of the session
     pub process_id: u32,
@@ -783,6 +790,16 @@ pub struct Connection {
     conn: RefCell<InnerConnection>
 }
 
+impl fmt::Show for Connection {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        let conn = self.conn.borrow();
+        write!(fmt,
+               "Connection {{ cancel_data: {:?}, notifications: {:?}, transaction_depth: {:?}, \
+                desynchronized: {:?} }}", conn.cancel_data, conn.notifications.len(),
+               conn.trans_depth, conn.desynchronized)
+    }
+}
+
 impl Connection {
     /// Creates a new connection to a Postgres database.
     ///
@@ -1056,6 +1073,8 @@ impl Connection {
 }
 
 /// Specifies the SSL support requested for a new connection
+// FIXME
+// #[derive(Show)]
 pub enum SslMode {
     /// The connection will not use SSL
     None,
@@ -1075,6 +1094,13 @@ pub struct Transaction<'conn> {
     finished: bool,
 }
 
+impl<'a> fmt::Show for Transaction<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Transaction {{ connection: {:?}, commit: {:?}, depth: {:?} }}",
+               self.conn, self.commit.get(), self.depth)
+    }
+}
+
 #[unsafe_destructor]
 impl<'conn> Drop for Transaction<'conn> {
     fn drop(&mut self) {
@@ -1205,6 +1231,18 @@ pub struct Statement<'conn> {
     finished: bool,
 }
 
+impl<'a> fmt::Show for Statement<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt,
+               "Statement {{ connection: {:?}, name: {:?}, parameter_types: {:?},
+                result_descriptions: {:?} }}",
+               self.conn,
+               self.name,
+               self.param_types,
+               self.result_desc)
+    }
+}
+
 #[unsafe_destructor]
 impl<'conn> Drop for Statement<'conn> {
     fn drop(&mut self) {
@@ -1382,7 +1420,7 @@ impl<'conn> Statement<'conn> {
 }
 
 /// Information about a column of the result of a query.
-#[derive(PartialEq, Eq)]
+#[derive(PartialEq, Eq, Clone, Show)]
 pub struct ResultDescription {
     /// The name of the column
     pub name: String,
@@ -1400,6 +1438,13 @@ pub struct Rows<'stmt> {
     finished: bool,
 }
 
+impl<'a> fmt::Show for Rows<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Rows {{ statement: {:?}, name: {:?}, remaining_rows: {:?} }}",
+               self.stmt, self.name, self.data.len())
+    }
+}
+
 #[unsafe_destructor]
 impl<'stmt> Drop for Rows<'stmt> {
     fn drop(&mut self) {
@@ -1511,6 +1556,12 @@ pub struct Row<'stmt> {
     data: Vec<Option<Vec<u8>>>
 }
 
+impl<'a> fmt::Show for Row<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Row {{ statement: {:?} }}", self.stmt)
+    }
+}
+
 impl<'stmt> Row<'stmt> {
     /// Returns the number of values in the row
     pub fn len(&self) -> usize {
@@ -1594,6 +1645,19 @@ pub struct LazyRows<'trans, 'stmt> {
     _trans: &'trans Transaction<'trans>,
 }
 
+impl<'a, 'b> fmt::Show for LazyRows<'a, 'b> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt,
+               "LazyRows {{ statement: {:?}, name: {:?}, row_limit: {:?}, remaining_rows: {:?}, \
+                more_rows: {:?} }}",
+               self.result.stmt,
+               self.result.name,
+               self.result.row_limit,
+               self.result.data.len(),
+               self.result.more_rows)
+    }
+}
+
 impl<'trans, 'stmt> LazyRows<'trans, 'stmt> {
     /// Like `Rows::finish`.
     pub fn finish(self) -> Result<()> {
@@ -1621,6 +1685,13 @@ pub struct CopyInStatement<'a> {
     finished: bool,
 }
 
+impl<'a> fmt::Show for CopyInStatement<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "CopyInStatement {{ connection: {:?}, name: {:?}, column_types: {:?} }}",
+               self.conn, self.name, self.column_types)
+    }
+}
+
 #[unsafe_destructor]
 impl<'a> Drop for CopyInStatement<'a> {
     fn drop(&mut self) {
@@ -1710,7 +1781,7 @@ impl<'a> CopyInStatement<'a> {
                                 // FIXME this is not the right way to handle this
                                 try_desync!(conn, conn.stream.write_message(
                                     &CopyFail {
-                                        message: &*format!("{:?}", err),
+                                        message: &*format!("{}", err),
                                     }));
                                 break 'l;
                             }