Flatten and rename error stuff

Author: sfackler

src/error.rs

@@ -16,21 +16,21 @@ macro_rules! make_errors(
         /// SQLSTATE error codes
         #[deriving(PartialEq, Eq, Clone, Show)]
         #[allow(missing_docs)]
-        pub enum PostgresSqlState {
+        pub enum SqlState {
             $($error,)+
-            UnknownSqlState(String)
+            Unknown(String)
         }
 
-        static STATE_MAP: phf::Map<&'static str, PostgresSqlState> = phf_map!(
-            $($code => $error),+
+        static STATE_MAP: phf::Map<&'static str, SqlState> = phf_map!(
+            $($code => SqlState::$error),+
         );
 
-        impl PostgresSqlState {
+        impl SqlState {
             #[doc(hidden)]
-            pub fn from_code(s: &str) -> PostgresSqlState {
+            pub fn from_code(s: &str) -> SqlState {
                 match STATE_MAP.find_equiv(s) {
                     Some(state) => state.clone(),
-                    None => UnknownSqlState(s.into_string())
+                    None => SqlState::Unknown(s.into_string())
                 }
             }
         }
@@ -358,15 +358,15 @@ make_errors!(
 
 /// Reasons a new Postgres connection could fail
 #[deriving(Clone, PartialEq, Eq)]
-pub enum PostgresConnectError {
+pub enum ConnectError {
     /// The provided URL could not be parsed
     InvalidUrl(String),
     /// The URL was missing a user
     MissingUser,
     /// There was an error opening a socket to the server
     SocketError(io::IoError),
     /// An error from the Postgres server itself
-    PgConnectDbError(PostgresDbError),
+    PgConnectDbError(DbError),
     /// A password was required but not provided in the URL
     MissingPassword,
     /// The Postgres server requested an authentication method not supported
@@ -382,7 +382,7 @@ pub enum PostgresConnectError {
     PgConnectBadResponse,
 }
 
-impl fmt::Show for PostgresConnectError {
+impl fmt::Show for ConnectError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             InvalidUrl(ref err) => write!(fmt, "Invalid URL: {}", err),
@@ -408,11 +408,11 @@ impl fmt::Show for PostgresConnectError {
 
 /// Represents the position of an error in a query
 #[deriving(Clone, PartialEq, Eq)]
-pub enum PostgresErrorPosition {
+pub enum ErrorPosition {
     /// A position in the original query
-    Position(uint),
+    Normal(uint),
     /// A position in an internally generated query
-    InternalPosition {
+    Internal {
         /// The byte position
         pub position: uint,
         /// A query generated by the Postgres server
@@ -422,13 +422,13 @@ pub enum PostgresErrorPosition {
 
 /// Encapsulates a Postgres error or notice.
 #[deriving(Clone, PartialEq, Eq)]
-pub struct PostgresDbError {
+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
     /// localized translation of one of these.
     pub severity: String,
     /// The SQLSTATE code for the error.
-    pub code: PostgresSqlState,
+    pub code: SqlState,
     /// The primary human-readable error message. This should be accurate but
     /// terse (typically one line).
     pub message: String,
@@ -441,7 +441,7 @@ pub struct PostgresDbError {
     pub hint: Option<String>,
     /// An optional error cursor position into either the original query string
     /// or an internally generated query.
-    pub position: Option<PostgresErrorPosition>,
+    pub position: Option<ErrorPosition>,
     /// An indication of the context in which the error occurred. Presently
     /// this includes a call stack traceback of active procedural language
     /// functions and internally-generated queries. The trace is one entry per
@@ -476,20 +476,20 @@ pub struct PostgresDbError {
     pub routine: String
 }
 
-impl PostgresDbError {
+impl DbError {
     #[doc(hidden)]
-    pub fn new_raw(fields: Vec<(u8, String)>) -> result::Result<PostgresDbError, ()> {
+    pub fn new_raw(fields: Vec<(u8, String)>) -> result::Result<DbError, ()> {
         let mut map: HashMap<_, _> = fields.into_iter().collect();
-        Ok(PostgresDbError {
+        Ok(DbError {
             severity: try!(map.pop(&b'S').ok_or(())),
-            code: PostgresSqlState::from_code(try!(map.pop(&b'C').ok_or(()))[]),
+            code: SqlState::from_code(try!(map.pop(&b'C').ok_or(()))[]),
             message: try!(map.pop(&b'M').ok_or(())),
             detail: map.pop(&b'D'),
             hint: map.pop(&b'H'),
             position: match map.pop(&b'P') {
-                Some(pos) => Some(Position(try!(from_str(pos[]).ok_or(())))),
+                Some(pos) => Some(ErrorPosition::Normal(try!(from_str(pos[]).ok_or(())))),
                 None => match map.pop(&b'p') {
-                    Some(pos) => Some(InternalPosition {
+                    Some(pos) => Some(ErrorPosition::Internal {
                         position: try!(from_str(pos[]).ok_or(())),
                         query: try!(map.pop(&b'q').ok_or(()))
                     }),
@@ -509,33 +509,33 @@ impl PostgresDbError {
     }
 
     #[doc(hidden)]
-    pub fn new_connect<T>(fields: Vec<(u8, String)>) -> result::Result<T, PostgresConnectError> {
-        match PostgresDbError::new_raw(fields) {
+    pub fn new_connect<T>(fields: Vec<(u8, String)>) -> result::Result<T, ConnectError> {
+        match DbError::new_raw(fields) {
             Ok(err) => Err(PgConnectDbError(err)),
             Err(()) => Err(PgConnectBadResponse),
         }
     }
 
     #[doc(hidden)]
     pub fn new<T>(fields: Vec<(u8, String)>) -> Result<T> {
-        match PostgresDbError::new_raw(fields) {
+        match DbError::new_raw(fields) {
             Ok(err) => Err(PgDbError(err)),
             Err(()) => Err(PgBadData),
         }
     }
 }
 
-impl fmt::Show for PostgresDbError {
+impl fmt::Show for DbError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         write!(fmt, "{}: {}", self.severity, self.message)
     }
 }
 
 /// An error encountered when communicating with the Postgres server
 #[deriving(Clone, PartialEq, Eq)]
-pub enum PostgresError {
+pub enum Error {
     /// An error reported by the Postgres server
-    PgDbError(PostgresDbError),
+    PgDbError(DbError),
     /// An error communicating with the Postgres server
     PgStreamError(io::IoError),
     /// The communication channel with the Postgres server has desynchronized
@@ -566,7 +566,7 @@ pub enum PostgresError {
     PgBadData,
 }
 
-impl fmt::Show for PostgresError {
+impl fmt::Show for Error {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             PgDbError(ref err) => err.fmt(fmt),

src/io.rs

@@ -5,7 +5,7 @@ use std::io::net::pipe;
 use std::io::{Stream, IoResult};
 
 use {ConnectParams, SslMode, NoSsl, PreferSsl, RequireSsl, ConnectTarget};
-use error::{PostgresConnectError, PgConnectStreamError, NoSslSupport, SslError, SocketError};
+use error::{ConnectError, PgConnectStreamError, NoSslSupport, SslError, SocketError};
 use message;
 use message::{SslRequest, WriteMessage};
 
@@ -72,7 +72,7 @@ impl Writer for InternalStream {
 }
 
 fn open_socket(params: &ConnectParams)
-               -> Result<InternalStream, PostgresConnectError> {
+               -> Result<InternalStream, ConnectError> {
     let port = params.port.unwrap_or(DEFAULT_PORT);
     let socket = match params.target {
         ConnectTarget::Tcp(ref host) =>
@@ -87,7 +87,7 @@ fn open_socket(params: &ConnectParams)
 }
 
 pub fn initialize_stream(params: &ConnectParams, ssl: &SslMode)
-                         -> Result<MaybeSslStream<InternalStream>, PostgresConnectError> {
+                         -> Result<MaybeSslStream<InternalStream>, ConnectError> {
     let mut socket = try!(open_socket(params));
 
     let (ssl_required, ctx) = match *ssl {