Merge branch 'release-v0.11.5' into release

Author: sfackler

.travis.yml

@@ -11,3 +11,4 @@ before_script:
 script:
 - cargo test
 - cargo test --features "uuid rustc-serialize time unix_socket serde_json chrono openssl bit-vec eui48"
+- (test $TRAVIS_RUST_VERSION != "nightly" || cargo test --features nightly)

Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "postgres"
-version = "0.11.4"
+version = "0.11.5"
 authors = ["Steven Fackler <[email protected]>"]
 license = "MIT"
 description = "A native PostgreSQL driver"
 repository = "https://github.com/sfackler/rust-postgres"
-documentation = "https://sfackler.github.io/rust-postgres/doc/v0.11.4/postgres"
+documentation = "https://sfackler.github.io/rust-postgres/doc/v0.11.5/postgres"
 readme = "README.md"
 keywords = ["database", "postgres", "postgresql", "sql"]
 include = ["src/*", "Cargo.toml", "LICENSE", "README.md", "THIRD_PARTY"]
@@ -20,11 +20,14 @@ bench = false
 name = "test"
 path = "tests/test.rs"
 
+[features]
+nightly = []
+
 [dependencies]
 bufstream = "0.1"
-byteorder = ">= 0.3, < 0.5"
+byteorder = "0.5"
 log = "0.3"
-phf = "0.7"
+phf = "=0.7.14"
 hex = "0.1"
 net2 = "0.2.16"
 rustc-serialize = { version = "0.3", optional = true }

README.md

@@ -1,7 +1,7 @@
 # Rust-Postgres
 A native PostgreSQL driver for Rust.
 
-[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.11.4/postgres)
+[Documentation](https://sfackler.github.io/rust-postgres/doc/v0.11.5/postgres)
 
 [![Build Status](https://travis-ci.org/sfackler/rust-postgres.png?branch=master)](https://travis-ci.org/sfackler/rust-postgres) [![Latest Version](https://img.shields.io/crates/v/postgres.svg)](https://crates.io/crates/postgres)
 
@@ -74,11 +74,11 @@ let conn = try!(Connection::connect("postgres://user:pass@host:port/database?arg
 defaults to the value of `user` if not specified. The driver supports `trust`,
 `password`, and `md5` authentication.
 
-Unix domain sockets can be used as well by activating the `unix_socket` feature.
-The `host` portion of the URI should be set to the absolute path to the
-directory containing the socket file. Since `/` is a reserved character in
-URLs, the path should be URL encoded. If Postgres stored its socket files in
-`/run/postgres`, the connection would then look like:
+Unix domain sockets can be used as well by activating the `unix_socket` or
+`nightly` features.  The `host` portion of the URI should be set to the absolute
+path to the directory containing the socket file. Since `/` is a reserved
+character in URLs, the path should be URL encoded. If Postgres stored its socket
+files in `/run/postgres`, the connection would then look like:
 ```rust
 let conn = try!(Connection::connect("postgres://postgres@%2Frun%2Fpostgres", SslMode::None));
 ```
@@ -269,7 +269,7 @@ The [postgres-derive](https://github.com/sfackler/rust-postgres-derive)
 crate will synthesize `ToSql` and `FromSql` implementations for enum, domain,
 and composite Postgres types.
 
-Support for array types is located in the
+Full support for array types is located in the
 [postgres-array](https://github.com/sfackler/rust-postgres-array) crate.
 
 Support for range types is located in the
@@ -284,8 +284,8 @@ crate.
 ### Unix socket connections
 
 Support for connections through Unix domain sockets is provided optionally by
-the `unix_socket` feature. It is only available on "unixy" platforms such as
-OSX, BSD and Linux.
+either the `unix_socket` or `nightly` features. It is only available on "unixy"
+platforms such as OSX, BSD and Linux.
 
 ### UUID type
 

codegen/Cargo.toml

@@ -4,6 +4,6 @@ version = "0.1.0"
 authors = ["Steven Fackler <[email protected]>"]
 
 [dependencies]
-phf_codegen = "0.7"
+phf_codegen = "=0.7.14"
 regex = "0.1"
 marksman_escape = "0.1"

src/error/mod.rs

@@ -1,6 +1,5 @@
 //! Error types.
 
-use byteorder;
 use std::error;
 use std::convert::From;
 use std::fmt;
@@ -227,12 +226,6 @@ impl From<DbError> for ConnectError {
     }
 }
 
-impl From<byteorder::Error> for ConnectError {
-    fn from(err: byteorder::Error) -> ConnectError {
-        ConnectError::Io(From::from(err))
-    }
-}
-
 /// Represents the position of an error in a query.
 #[derive(Clone, PartialEq, Eq, Debug)]
 pub enum ErrorPosition {
@@ -299,12 +292,6 @@ impl From<io::Error> for Error {
     }
 }
 
-impl From<byteorder::Error> for Error {
-    fn from(err: byteorder::Error) -> Error {
-        Error::Io(From::from(err))
-    }
-}
-
 impl From<Error> for io::Error {
     fn from(err: Error) -> io::Error {
         io::Error::new(io::ErrorKind::Other, err)

src/error/sqlstate.rs

@@ -482,7 +482,7 @@ pub enum SqlState {
 #[cfg_attr(rustfmt, rustfmt_skip)]
 static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map {
     key: 1897749892740154578,
-    disps: &[
+    disps: ::phf::Slice::Static(&[
         (0, 10),
         (1, 206),
         (0, 38),
@@ -531,8 +531,8 @@ static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map {
         (0, 233),
         (2, 149),
         (0, 105),
-    ],
-    entries: &[
+    ]),
+    entries: ::phf::Slice::Static(&[
         ("42P03", SqlState::DuplicateCursor),
         ("22019", SqlState::InvalidEscapeCharacter),
         ("22022", SqlState::IndicatorOverflow),
@@ -769,7 +769,7 @@ static SQLSTATE_MAP: phf::Map<&'static str, SqlState> = ::phf::Map {
         ("28000", SqlState::InvalidAuthorizationSpecification),
         ("0Z002", SqlState::StackedDiagnosticsAccessedWithoutActiveHandler),
         ("02000", SqlState::NoData),
-    ]
+    ]),
 };
 
 impl SqlState {

src/lib.rs

@@ -38,9 +38,10 @@
 //!     }
 //! }
 //! ```
-#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.11.4")]
+#![doc(html_root_url="https://sfackler.github.io/rust-postgres/doc/v0.11.5")]
 #![warn(missing_docs)]
 #![allow(unknown_lints, needless_lifetimes)] // for clippy
+#![cfg_attr(all(unix, feature = "nightly"), feature(unix_socket))]
 
 extern crate bufstream;
 extern crate byteorder;
@@ -68,7 +69,7 @@ use std::mem;
 use std::result;
 use std::sync::Arc;
 use std::time::Duration;
-#[cfg(feature = "unix_socket")]
+#[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
 use std::path::PathBuf;
 
 // FIXME remove in 0.12
@@ -115,8 +116,8 @@ pub enum ConnectTarget {
     Tcp(String),
     /// Connect via a Unix domain socket in the specified directory.
     ///
-    /// Requires the `unix_socket` feature.
-    #[cfg(feature = "unix_socket")]
+    /// Requires the `unix_socket` or `nightly` feature.
+    #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
     Unix(PathBuf),
 }
 
@@ -173,14 +174,14 @@ impl<'a> IntoConnectParams for &'a str {
 
 impl IntoConnectParams for Url {
     fn into_connect_params(self) -> result::Result<ConnectParams, Box<StdError + StdSync + Send>> {
-        #[cfg(feature = "unix_socket")]
+        #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
         fn make_unix(maybe_path: String)
                      -> result::Result<ConnectTarget, Box<StdError + StdSync + Send>> {
             Ok(ConnectTarget::Unix(PathBuf::from(maybe_path)))
         }
-        #[cfg(not(feature = "unix_socket"))]
+        #[cfg(not(any(feature = "unix_socket", all(unix, feature = "nightly"))))]
         fn make_unix(_: String) -> result::Result<ConnectTarget, Box<StdError + StdSync + Send>> {
-            Err("unix socket support requires the `unix_socket` feature".into())
+            Err("unix socket support requires the `unix_socket` or `nightly` features".into())
         }
 
         let Url { host, port, user, path: url::Path { mut path, query: options, .. }, .. } = self;
@@ -1019,13 +1020,13 @@ impl Connection {
     /// (5432) is used if none is specified. The database name defaults to the
     /// username if not specified.
     ///
-    /// Connection via Unix sockets is supported with the `unix_socket`
-    /// feature. To connect to the server via Unix sockets, `host` should be
-    /// set to the absolute path of the directory containing the socket file.
-    /// Since `/` is a reserved character in URLs, the path should be URL
-    /// encoded. If the path contains non-UTF 8 characters, a `ConnectParams`
-    /// struct should be created manually and passed in. Note that Postgres
-    /// does not support SSL over Unix sockets.
+    /// Connection via Unix sockets is supported with either the `unix_socket`
+    /// or `nightly` features. To connect to the server via Unix sockets, `host`
+    /// should be set to the absolute path of the directory containing the
+    /// socket file.  Since `/` is a reserved character in URLs, the path should
+    /// be URL encoded. If the path contains non-UTF 8 characters, a
+    /// `ConnectParams` struct should be created manually and passed in. Note
+    /// that Postgres does not support SSL over Unix sockets.
     ///
     /// # Examples
     ///

src/priv_io.rs

@@ -9,6 +9,8 @@ use std::time::Duration;
 use bufstream::BufStream;
 #[cfg(feature = "unix_socket")]
 use unix_socket::UnixStream;
+#[cfg(all(not(feature = "unix_socket"), all(unix, feature = "nightly")))]
+use std::os::unix::net::UnixStream;
 #[cfg(unix)]
 use std::os::unix::io::{AsRawFd, RawFd};
 #[cfg(windows)]
@@ -32,15 +34,15 @@ impl StreamOptions for BufStream<Box<StreamWrapper>> {
     fn set_read_timeout(&self, timeout: Option<Duration>) -> io::Result<()> {
         match self.get_ref().get_ref().0 {
             InternalStream::Tcp(ref s) => s.set_read_timeout(timeout),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref s) => s.set_read_timeout(timeout),
         }
     }
 
     fn set_nonblocking(&self, nonblock: bool) -> io::Result<()> {
         match self.get_ref().get_ref().0 {
             InternalStream::Tcp(ref s) => s.set_nonblocking(nonblock),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref s) => s.set_nonblocking(nonblock),
         }
     }
@@ -56,7 +58,7 @@ impl fmt::Debug for Stream {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match self.0 {
             InternalStream::Tcp(ref s) => fmt::Debug::fmt(s, fmt),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref s) => fmt::Debug::fmt(s, fmt),
         }
     }
@@ -93,7 +95,7 @@ impl AsRawFd for Stream {
     fn as_raw_fd(&self) -> RawFd {
         match self.0 {
             InternalStream::Tcp(ref s) => s.as_raw_fd(),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref s) => s.as_raw_fd(),
         }
     }
@@ -111,15 +113,15 @@ impl AsRawSocket for Stream {
 
 enum InternalStream {
     Tcp(TcpStream),
-    #[cfg(feature = "unix_socket")]
+    #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
     Unix(UnixStream),
 }
 
 impl Read for InternalStream {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         match *self {
             InternalStream::Tcp(ref mut s) => s.read(buf),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref mut s) => s.read(buf),
         }
     }
@@ -129,15 +131,15 @@ impl Write for InternalStream {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         match *self {
             InternalStream::Tcp(ref mut s) => s.write(buf),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref mut s) => s.write(buf),
         }
     }
 
     fn flush(&mut self) -> io::Result<()> {
         match *self {
             InternalStream::Tcp(ref mut s) => s.flush(),
-            #[cfg(feature = "unix_socket")]
+            #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
             InternalStream::Unix(ref mut s) => s.flush(),
         }
     }
@@ -149,7 +151,7 @@ fn open_socket(params: &ConnectParams) -> Result<InternalStream, ConnectError> {
         ConnectTarget::Tcp(ref host) => {
             Ok(try!(TcpStream::connect(&(&**host, port)).map(InternalStream::Tcp)))
         }
-        #[cfg(feature = "unix_socket")]
+        #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
         ConnectTarget::Unix(ref path) => {
             let path = path.join(&format!(".s.PGSQL.{}", port));
             Ok(try!(UnixStream::connect(&path).map(InternalStream::Unix)))
@@ -183,7 +185,7 @@ pub fn initialize_stream(params: &ConnectParams,
     // Postgres doesn't support SSL over unix sockets
     let host = match params.target {
         ConnectTarget::Tcp(ref host) => host,
-        #[cfg(feature = "unix_socket")]
+        #[cfg(any(feature = "unix_socket", all(unix, feature = "nightly")))]
         ConnectTarget::Unix(_) => return Err(ConnectError::Io(::bad_response())),
     };