Rustfmt

src/types/chrono.rs

@@ -53,7 +53,8 @@ impl FromSql for NaiveTime {
     }
 }
 
-/// ISO 8601 combined date and time without timezone => "YYYY-MM-DD HH:MM:SS.SSS"
+/// ISO 8601 combined date and time without timezone =>
+/// "YYYY-MM-DD HH:MM:SS.SSS"
 impl ToSql for NaiveDateTime {
     fn to_sql(&self) -> Result<ToSqlOutput> {
         let date_str = self.format("%Y-%m-%dT%H:%M:%S%.f").to_string();
@@ -61,8 +62,9 @@ impl ToSql for NaiveDateTime {
     }
 }
 
-/// "YYYY-MM-DD HH:MM:SS"/"YYYY-MM-DD HH:MM:SS.SSS" => ISO 8601 combined date and time
-/// without timezone. ("YYYY-MM-DDTHH:MM:SS"/"YYYY-MM-DDTHH:MM:SS.SSS" also supported)
+/// "YYYY-MM-DD HH:MM:SS"/"YYYY-MM-DD HH:MM:SS.SSS" => ISO 8601 combined date
+/// and time without timezone. ("YYYY-MM-DDTHH:MM:SS"/"YYYY-MM-DDTHH:MM:SS.SSS"
+/// also supported)
 impl FromSql for NaiveDateTime {
     fn column_result(value: ValueRef) -> FromSqlResult<Self> {
         value.as_str().and_then(|s| {
@@ -80,7 +82,8 @@ impl FromSql for NaiveDateTime {
     }
 }
 
-/// Date and time with time zone => UTC RFC3339 timestamp ("YYYY-MM-DDTHH:MM:SS.SSS+00:00").
+/// Date and time with time zone => UTC RFC3339 timestamp
+/// ("YYYY-MM-DDTHH:MM:SS.SSS+00:00").
 impl<Tz: TimeZone> ToSql for DateTime<Tz> {
     fn to_sql(&self) -> Result<ToSqlOutput> {
         Ok(ToSqlOutput::from(self.with_timezone(&Utc).to_rfc3339()))

src/types/from_sql.rs

@@ -5,11 +5,12 @@ use std::fmt;
 /// Enum listing possible errors from `FromSql` trait.
 #[derive(Debug)]
 pub enum FromSqlError {
-    /// Error when an SQLite value is requested, but the type of the result cannot be converted to
-    /// the requested Rust type.
+    /// Error when an SQLite value is requested, but the type of the result
+    /// cannot be converted to the requested Rust type.
     InvalidType,
 
-    /// Error when the i64 value returned by SQLite cannot be stored into the requested type.
+    /// Error when the i64 value returned by SQLite cannot be stored into the
+    /// requested type.
     OutOfRange(i64),
 
     /// An error case available for implementors of the `FromSql` trait.
@@ -49,13 +50,15 @@ pub type FromSqlResult<T> = Result<T, FromSqlError>;
 
 /// A trait for types that can be created from a SQLite value.
 ///
-/// Note that `FromSql` and `ToSql` are defined for most integral types, but not `u64` or `usize`.
-/// This is intentional; SQLite returns integers as signed 64-bit values, which cannot fully
-/// represent the range of these types. Rusqlite would have to decide how to handle negative
-/// values: return an error or reinterpret as a very large postive numbers, neither of which is
-/// guaranteed to be correct for everyone. Callers can work around this by fetching values as i64
-/// and then doing the interpretation themselves or by defining a newtype and implementing
-/// `FromSql`/`ToSql` for it.
+/// Note that `FromSql` and `ToSql` are defined for most integral types, but
+/// not `u64` or `usize`. This is intentional; SQLite returns integers as
+/// signed 64-bit values, which cannot fully represent the range of these
+/// types. Rusqlite would have to
+/// decide how to handle negative values: return an error or reinterpret as a
+/// very large postive numbers, neither of which
+/// is guaranteed to be correct for everyone. Callers can work around this by
+/// fetching values as i64 and then doing the interpretation themselves or by
+/// defining a newtype and implementing `FromSql`/`ToSql` for it.
 pub trait FromSql: Sized {
     fn column_result(value: ValueRef) -> FromSqlResult<Self>;
 }

src/types/mod.rs

@@ -1,11 +1,11 @@
 //! Traits dealing with SQLite data types.
 //!
 //! SQLite uses a [dynamic type system](https://www.sqlite.org/datatype3.html). Implementations of
-//! the `ToSql` and `FromSql` traits are provided for the basic types that SQLite provides methods
-//! for:
+//! the `ToSql` and `FromSql` traits are provided for the basic types that
+//! SQLite provides methods for:
 //!
-//! * Integers (`i32` and `i64`; SQLite uses `i64` internally, so getting an `i32` will truncate
-//!   if the value is too large or too small).
+//! * Integers (`i32` and `i64`; SQLite uses `i64` internally, so getting an
+//! `i32` will truncate   if the value is too large or too small).
 //! * Reals (`f64`)
 //! * Strings (`String` and `&str`)
 //! * Blobs (`Vec<u8>` and `&[u8]`)
@@ -22,16 +22,18 @@
 //! extern crate rusqlite;
 //! extern crate time;
 //!
-//! use rusqlite::types::{FromSql, FromSqlResult, ValueRef, ToSql, ToSqlOutput};
-//! use rusqlite::{Result};
+//! use rusqlite::types::{FromSql, FromSqlResult, ToSql, ToSqlOutput, ValueRef};
+//! use rusqlite::Result;
 //!
 //! pub struct TimespecSql(pub time::Timespec);
 //!
 //! impl FromSql for TimespecSql {
 //!     fn column_result(value: ValueRef) -> FromSqlResult<Self> {
 //!         f64::column_result(value).map(|as_f64| {
-//!             TimespecSql(time::Timespec{ sec: as_f64.trunc() as i64,
-//!                                         nsec: (as_f64.fract() * 1.0e9) as i32 })
+//!             TimespecSql(time::Timespec {
+//!                 sec: as_f64.trunc() as i64,
+//!                 nsec: (as_f64.fract() * 1.0e9) as i32,
+//!             })
 //!         })
 //!     }
 //! }
@@ -48,9 +50,9 @@
 //! # fn main() {}
 //! ```
 //!
-//! `ToSql` and `FromSql` are also implemented for `Option<T>` where `T` implements `ToSql` or
-//! `FromSql` for the cases where you want to know if a value was NULL (which gets translated to
-//! `None`).
+//! `ToSql` and `FromSql` are also implemented for `Option<T>` where `T`
+//! implements `ToSql` or `FromSql` for the cases where you want to know if a
+//! value was NULL (which gets translated to `None`).
 
 pub use self::from_sql::{FromSql, FromSqlError, FromSqlResult};
 pub use self::to_sql::{ToSql, ToSqlOutput};
@@ -77,8 +79,7 @@ mod value_ref;
 /// # extern crate rusqlite;
 /// # use rusqlite::{Connection, Result};
 /// # use rusqlite::types::{Null};
-/// fn main() {
-/// }
+/// fn main() {}
 /// fn insert_null(conn: &Connection) -> Result<usize> {
 ///     conn.execute("INSERT INTO people (name) VALUES (?)", &[&Null])
 /// }

src/types/to_sql.rs

@@ -4,7 +4,8 @@ use std::borrow::Cow;
 use vtab::array::Array;
 use Result;
 
-/// `ToSqlOutput` represents the possible output types for implementors of the `ToSql` trait.
+/// `ToSqlOutput` represents the possible output types for implementors of the
+/// `ToSql` trait.
 #[derive(Clone, Debug, PartialEq)]
 pub enum ToSqlOutput<'a> {
     /// A borrowed SQLite-representable value.

src/types/value_ref.rs

@@ -32,8 +32,8 @@ impl<'a> ValueRef<'a> {
 }
 
 impl<'a> ValueRef<'a> {
-    /// If `self` is case `Integer`, returns the integral value. Otherwise, returns
-    /// `Err(Error::InvalidColumnType)`.
+    /// If `self` is case `Integer`, returns the integral value. Otherwise,
+    /// returns `Err(Error::InvalidColumnType)`.
     pub fn as_i64(&self) -> FromSqlResult<i64> {
         match *self {
             ValueRef::Integer(i) => Ok(i),
@@ -41,8 +41,8 @@ impl<'a> ValueRef<'a> {
         }
     }
 
-    /// If `self` is case `Real`, returns the floating point value. Otherwise, returns
-    /// `Err(Error::InvalidColumnType)`.
+    /// If `self` is case `Real`, returns the floating point value. Otherwise,
+    /// returns `Err(Error::InvalidColumnType)`.
     pub fn as_f64(&self) -> FromSqlResult<f64> {
         match *self {
             ValueRef::Real(f) => Ok(f),