Merge pull request #25 from jgallagher/rust-stabilization

Rust stabilization

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rusqlite"
-version = "0.0.11"
+version = "0.0.12"
 authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
 description = "Ergonomic wrapper for SQLite"
 repository = "https://github.com/jgallagher/rusqlite"

Changelog.md

@@ -1,3 +1,7 @@
+# Version 0.0.12 (2015-03-24)
+
+* Updates to track rustc stabilization.
+
 # Version 0.0.11 (2015-03-12)
 
 * Reexport `sqlite3_stmt` from `libsqlite3-sys` for easier `impl`-ing of `ToSql` and `FromSql`.

src/lib.rs

@@ -48,12 +48,12 @@
 //!     }
 //! }
 //! ```
-#![feature(unsafe_destructor, core, path, libc, rustc_private, collections)]
+#![feature(unsafe_destructor, core, libc)]
 #![cfg_attr(test, feature(test))]
 
 extern crate libc;
 extern crate "libsqlite3-sys" as ffi;
-#[macro_use] extern crate rustc_bitflags;
+#[macro_use] extern crate bitflags;
 
 use std::mem;
 use std::ptr;
@@ -109,7 +109,7 @@ impl fmt::Display for SqliteError {
 
 impl error::Error for SqliteError {
     fn description(&self) -> &str {
-        self.message.as_slice()
+        &self.message
     }
 }
 
@@ -900,13 +900,13 @@ mod test {
             let rows = query.query(&[&4i32]).unwrap();
             let v: Vec<i32> = rows.map(|r| r.unwrap().get(0)).collect();
 
-            assert_eq!(v.as_slice(), [3i32, 2, 1].as_slice());
+            assert_eq!(v, [3i32, 2, 1]);
         }
 
         {
             let rows = query.query(&[&3i32]).unwrap();
             let v: Vec<i32> = rows.map(|r| r.unwrap().get(0)).collect();
-            assert_eq!(v.as_slice(), [2i32, 1].as_slice());
+            assert_eq!(v, [2i32, 1]);
         }
     }
 
@@ -930,7 +930,7 @@ mod test {
         let error = result.unwrap_err();
 
         assert!(error.code == ffi::SQLITE_NOTICE);
-        assert!(error.message.as_slice() == "Query did not return a row");
+        assert!(error.message == "Query did not return a row");
 
         let bad_query_result = db.query_row_safe("NOT A PROPER QUERY; test123", &[], |_| ());
 
@@ -943,7 +943,7 @@ mod test {
         db.execute_batch("CREATE TABLE foo(x INTEGER);").unwrap();
 
         let err = db.prepare("SELECT * FROM does_not_exist").unwrap_err();
-        assert!(err.message.as_slice().contains("does_not_exist"));
+        assert!(err.message.contains("does_not_exist"));
     }
 
     #[test]
@@ -961,7 +961,7 @@ mod test {
         assert_eq!(2i32, second.get(0));
 
         let result = first.get_opt::<i32>(0);
-        assert!(result.unwrap_err().message.as_slice().contains("advancing to next row"));
+        assert!(result.unwrap_err().message.contains("advancing to next row"));
     }
 
     #[test]
@@ -973,7 +973,7 @@ mod test {
         assert_eq!(db.last_insert_rowid(), 1);
 
         let mut stmt = db.prepare("INSERT INTO foo DEFAULT VALUES").unwrap();
-        for _ in range(0i32, 9) {
+        for _ in 0i32 .. 9 {
             stmt.execute(&[]).unwrap();
         }
         assert_eq!(db.last_insert_rowid(), 10);

src/transaction.rs

@@ -240,7 +240,7 @@ mod test {
         let mut stmt = db.prepare("INSERT INTO foo VALUES(1)").unwrap();
 
         bencher.iter(|| {
-            for _ in range(0i32, 1000) {
+            for _ in 0i32 .. 1000 {
                 stmt.execute(&[]).unwrap();
             }
         })
@@ -255,7 +255,7 @@ mod test {
         bencher.iter(|| {
             let mut tx = db.transaction().unwrap();
             tx.set_commit();
-            for _ in range(0i32, 1000) {
+            for _ in 0i32 .. 1000 {
                 stmt.execute(&[]).unwrap();
             }
         })

src/types.rs

@@ -101,7 +101,7 @@ impl<'a> ToSql for &'a str {
 
 impl ToSql for String {
     unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
-        self.as_slice().bind_parameter(stmt, col)
+        (&self[..]).bind_parameter(stmt, col)
     }
 }
 
@@ -115,7 +115,7 @@ impl<'a> ToSql for &'a [u8] {
 
 impl ToSql for Vec<u8> {
     unsafe fn bind_parameter(&self, stmt: *mut sqlite3_stmt, col: c_int) -> c_int {
-        self.as_slice().bind_parameter(stmt, col)
+        (&self[..]).bind_parameter(stmt, col)
     }
 }
 
@@ -192,12 +192,13 @@ impl FromSql for String {
 
 impl FromSql for Vec<u8> {
     unsafe fn column_result(stmt: *mut sqlite3_stmt, col: c_int) -> SqliteResult<Vec<u8>> {
+        use std::slice::from_raw_parts;
         let c_blob = ffi::sqlite3_column_blob(stmt, col);
         let len = ffi::sqlite3_column_bytes(stmt, col);
 
         assert!(len >= 0); let len = len as usize;
 
-        Ok(Vec::from_raw_buf(mem::transmute(c_blob), len))
+        Ok(from_raw_parts(mem::transmute(c_blob), len).to_vec())
     }
 }
 
@@ -206,7 +207,7 @@ impl FromSql for time::Timespec {
                             col: c_int) -> SqliteResult<time::Timespec> {
         let col_str = FromSql::column_result(stmt, col);
         col_str.and_then(|txt: String| {
-            time::strptime(txt.as_slice(), SQLITE_DATETIME_FMT).map(|tm| {
+            time::strptime(&txt, SQLITE_DATETIME_FMT).map(|tm| {
                 tm.to_timespec()
             }).map_err(|parse_error| {
                 SqliteError{ code: ffi::SQLITE_MISMATCH, message: format!("{}", parse_error) }
@@ -255,7 +256,7 @@ mod test {
         db.execute("INSERT INTO foo(t) VALUES (?)", &[&s.to_string()]).unwrap();
 
         let from: String = db.query_row("SELECT t FROM foo", &[], |r| r.get(0));
-        assert_eq!(from.as_slice(), s);
+        assert_eq!(from, s);
     }
 
     #[test]
@@ -285,7 +286,7 @@ mod test {
         let row1 = rows.next().unwrap().unwrap();
         let s1: Option<String> = row1.get(0);
         let b1: Option<Vec<u8>> = row1.get(1);
-        assert_eq!(s.unwrap(), s1.unwrap().as_slice());
+        assert_eq!(s.unwrap(), s1.unwrap());
         assert!(b1.is_none());
 
         let row2 = rows.next().unwrap().unwrap();