Use no_run for doc tests

Author: sfackler

src/lib.rs

@@ -3,7 +3,7 @@ Rust-Postgres is a pure-Rust frontend for the popular PostgreSQL database. It
 exposes a high level interface in the vein of JDBC or Go's `database/sql`
 package.
 
-```rust
+```rust,no_run
 extern crate postgres;
 extern crate time;
 
@@ -19,7 +19,6 @@ struct Person {
     data: Option<~[u8]>
 }
 
-# fn main() {
 fn main() {
     let conn = PostgresConnection::connect("postgres://postgres@localhost",
                                            &NoSsl);
@@ -52,7 +51,6 @@ fn main() {
         println!("Found person {}", person.name);
     }
 }
-# }
 ```
  */
 
@@ -270,10 +268,7 @@ pub struct PostgresCancelData {
 ///
 /// # Example
 ///
-/// ```rust
-/// # extern crate postgres;
-/// # fn main() {}
-/// # fn foo() {
+/// ```rust,no_run
 /// # use postgres::{PostgresConnection, NoSsl};
 /// # let url = "";
 /// let conn = PostgresConnection::connect(url, &NoSsl);
@@ -283,7 +278,6 @@ pub struct PostgresCancelData {
 /// });
 /// # let _ =
 /// postgres::cancel_query(url, &NoSsl, cancel_data);
-/// # }
 /// ```
 pub fn cancel_query(url: &str, ssl: &SslMode, data: PostgresCancelData)
         -> Result<(), PostgresConnectError> {
@@ -712,17 +706,14 @@ impl PostgresConnection {
     ///
     /// # Example
     ///
-    /// ```rust
-    /// # fn main() {}
-    /// # fn foo() {
+    /// ```rust,no_run
     /// # use postgres::{PostgresConnection, NoSsl};
     /// let url = "postgres://postgres:hunter2@localhost:2994/foodb";
     /// let maybe_conn = PostgresConnection::try_connect(url, &NoSsl);
     /// let conn = match maybe_conn {
     ///     Ok(conn) => conn,
     ///     Err(err) => fail!("Error connecting: {}", err)
     /// };
-    /// # }
     /// ```
     pub fn try_connect(url: &str, ssl: &SslMode)
             -> Result<PostgresConnection, PostgresConnectError> {
@@ -772,17 +763,14 @@ impl PostgresConnection {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use postgres::{PostgresConnection, NoSsl};
-    /// # fn main() {}
-    /// # fn foo() {
     /// # let conn = PostgresConnection::connect("", &NoSsl);
     /// let maybe_stmt = conn.try_prepare("SELECT foo FROM bar WHERE baz = $1");
     /// let stmt = match maybe_stmt {
     ///     Ok(stmt) => stmt,
     ///     Err(err) => fail!("Error preparing statement: {}", err)
     /// };
-    /// # }
     pub fn try_prepare<'a>(&'a self, query: &str)
             -> Result<NormalPostgresStatement<'a>, PostgresError> {
         self.conn.with_mut(|conn| conn.try_prepare(query, self))
@@ -811,9 +799,8 @@ impl PostgresConnection {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use postgres::{PostgresConnection, NoSsl};
-    /// # fn main() {}
     /// # fn foo() -> Result<(), postgres::error::PostgresError> {
     /// # let conn = PostgresConnection::connect("", &NoSsl);
     /// let trans = try!(conn.try_transaction());

src/pool.rs

@@ -36,11 +36,9 @@ impl InnerConnectionPool {
 ///
 /// # Example
 ///
-/// ```rust
+/// ```rust,no_run
 /// # use postgres::NoSsl;
 /// # use postgres::pool::PostgresConnectionPool;
-/// # fn main() {}
-/// # fn foo() {
 /// let pool = PostgresConnectionPool::new("postgres://postgres@localhost",
 ///                                        NoSsl, 5);
 /// for _ in range(0, 10) {
@@ -50,7 +48,6 @@ impl InnerConnectionPool {
 ///         conn.execute("UPDATE foo SET bar = 1", []);
 ///     });
 /// }
-/// # }
 /// ```
 #[deriving(Clone)]
 pub struct PostgresConnectionPool {

src/stmt.rs

@@ -40,11 +40,9 @@ pub trait PostgresStatement {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use postgres::{PostgresConnection, NoSsl, PostgresStatement};
     /// # use postgres::types::ToSql;
-    /// # fn main() {}
-    /// # fn foo() {
     /// # let conn = PostgresConnection::connect("", &NoSsl);
     /// # let bar = 1i32;
     /// # let baz = true;
@@ -53,7 +51,6 @@ pub trait PostgresStatement {
     ///     Ok(count) => println!("{} row(s) updated", count),
     ///     Err(err) => println!("Error executing query: {}", err)
     /// }
-    /// # }
     fn try_execute(&self, params: &[&ToSql]) -> Result<uint, PostgresError>;
 
     /// A convenience function wrapping `try_execute`.
@@ -78,11 +75,9 @@ pub trait PostgresStatement {
     ///
     /// # Example
     ///
-    /// ```rust
+    /// ```rust,no_run
     /// # use postgres::{PostgresConnection, NoSsl, PostgresStatement};
     /// # use postgres::types::ToSql;
-    /// # fn main() {}
-    /// # fn foo() {
     /// # let conn = PostgresConnection::connect("", &NoSsl);
     /// let stmt = conn.prepare("SELECT foo FROM bar WHERE baz = $1");
     /// # let baz = true;
@@ -94,7 +89,6 @@ pub trait PostgresStatement {
     ///     let foo: i32 = row["foo"];
     ///     println!("foo: {}", foo);
     /// }
-    /// # }
     /// ```
     fn try_query<'a>(&'a self, params: &[&ToSql])
             -> Result<PostgresResult<'a>, PostgresError>;
@@ -509,18 +503,14 @@ impl<'stmt> Iterator<PostgresRow<'stmt>> for PostgresResult<'stmt> {
 /// A value can be accessed by the name or index of its column, though access
 /// by index is more efficient. Rows are 1-indexed.
 ///
-/// ```rust
-/// # extern crate postgres;
+/// ```rust,no_run
 /// # use postgres::{PostgresConnection, PostgresStatement, NoSsl};
-/// # fn main() {}
-/// # fn foo() {
 /// # let conn = PostgresConnection::connect("", &NoSsl);
 /// # let stmt = conn.prepare("");
 /// # let mut result = stmt.query([]);
 /// # let row = result.next().unwrap();
 /// let foo: i32 = row[1];
 /// let bar: ~str = row["bar"];
-/// # }
 /// ```
 pub struct PostgresRow<'stmt> {
     priv stmt: &'stmt NormalPostgresStatement<'stmt>,