Do not make use of globs feature

`pub use` globs will be removed from the language, but non-public globs
are still buggy, see: rust-lang/rust#3352

Author: aflatter

src/sqlite3/database.rs

@@ -29,12 +29,19 @@
 ** POSSIBILITY OF SUCH DAMAGE.
 */
 
-use statement::*;
-use ffi::*;
+use types::{ResultCode,
+            SQLITE_OK,
+            SQLITE_ERROR};
+
+use types::{dbh,
+            SqliteResult};
+
+use statement::Statement;
+use ffi;
+
 use libc::c_int;
 use std::ptr;
 use std::str;
-use types::*;
 
 /// The database connection.
 pub struct Database {
@@ -51,19 +58,17 @@ impl Drop for Database {
     fn drop(&mut self) {
         debug!("`Database.drop()`: dbh={:?}", self.dbh);
         unsafe {
-            sqlite3_close(self.dbh);
+            ffi::sqlite3_close(self.dbh);
         }
     }
 }
 
 impl Database {
-
     /// Returns the error message of the the most recent call.
     /// See http://www.sqlite.org/c3ref/errcode.html
     pub fn get_errmsg(&self) -> ~str {
         unsafe {
-            str::raw::from_c_str(sqlite3_errmsg(self.dbh))
-        }
+            str::raw::from_c_str(ffi::sqlite3_errmsg(self.dbh)) }
     }
 
     /// Prepares/compiles an SQL statement.
@@ -72,7 +77,7 @@ impl Database {
         let new_stmt = ptr::null();
         let r = sql.with_c_str( |_sql| {
             unsafe {
-                sqlite3_prepare_v2(self.dbh, _sql, sql.len() as c_int, &new_stmt, ptr::null())
+                ffi::sqlite3_prepare_v2(self.dbh, _sql, sql.len() as c_int, &new_stmt, ptr::null())
             }
         });
         if r == SQLITE_OK {
@@ -89,7 +94,7 @@ impl Database {
         let mut r = SQLITE_ERROR;
         sql.with_c_str( |_sql| {
             unsafe {
-                r = sqlite3_exec(self.dbh, _sql, ptr::null(), ptr::null(), ptr::null())
+                r = ffi::sqlite3_exec(self.dbh, _sql, ptr::null(), ptr::null(), ptr::null())
             }
         });
 
@@ -101,23 +106,23 @@ impl Database {
     /// See http://www.sqlite.org/c3ref/changes.html
     pub fn get_changes(&self) -> int {
         unsafe {
-            sqlite3_changes(self.dbh) as int
+            ffi::sqlite3_changes(self.dbh) as int
         }
     }
 
     /// Returns the ID of the last inserted row.
     /// See http://www.sqlite.org/c3ref/last_insert_rowid.html
     pub fn get_last_insert_rowid(&self) -> i64 {
         unsafe {
-            sqlite3_last_insert_rowid(self.dbh)
+            ffi::sqlite3_last_insert_rowid(self.dbh)
         }
     }
 
     /// Sets a busy timeout.
     /// See http://www.sqlite.org/c3ref/busy_timeout.html
     pub fn set_busy_timeout(&self, ms: int) -> ResultCode {
         unsafe {
-            sqlite3_busy_timeout(self.dbh, ms as c_int)
+            ffi::sqlite3_busy_timeout(self.dbh, ms as c_int)
         }
     }
 }

src/sqlite3/ffi.rs

@@ -29,8 +29,8 @@
 ** POSSIBILITY OF SUCH DAMAGE.
 */
 
-use libc::*;
-use types::*;
+use libc::{c_char,c_int,c_void};
+use types::{ResultCode,stmt,dbh,_notused};
 
 #[link(name = "sqlite3")]
 extern {

src/sqlite3/lib.rs

@@ -1,6 +1,6 @@
 #![crate_id="sqlite3#0.1"]
 #![crate_type = "lib"]
-#![feature(globs, phase)]
+#![feature(phase)]
 #[phase(syntax, link)] extern crate log;
 
 /*
@@ -37,15 +37,18 @@
 extern crate libc;
 extern crate collections;
 
-pub use statement::*;
-pub use database::*;
-use ffi::*;
-pub use types::*;
+pub use database::Database;
+pub use statement::Statement;
+pub use types::SqliteResult;
+
+use types::{SQLITE_OK,SQLITE_NOMEM};
+use ffi::{sqlite3_complete};
+
 use std::ptr;
 
-pub mod statement;
-pub mod database;
 mod ffi;
+mod database;
+mod statement;
 
 #[allow(non_camel_case_types)]
 pub mod types;
@@ -79,26 +82,27 @@ pub fn open(path: &str) -> SqliteResult<Database> {
     let dbh = ptr::null();
     let r = path.with_c_str( |_path| {
         unsafe {
-            sqlite3_open(_path, &dbh)
+            ffi::sqlite3_open(_path, &dbh)
         }
     });
     if r != SQLITE_OK {
         unsafe {
-            sqlite3_close(dbh);
+            ffi::sqlite3_close(dbh);
         }
         Err(r)
     } else {
         debug!("`open()`: dbh={:?}", dbh);
-        Ok(database_with_handle(dbh))
+        Ok(database::database_with_handle(dbh))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use statement::*;
-    use database::*;
-    use super::*;
-    use types::*;
+    use types::{Integer,Integer64,Text,Float64,StaticText};
+    use types::{SQLITE_DONE,SQLITE_ROW,SQLITE_OK};
+    use types::{SqliteResult};
+    use statement::Statement;
+    use database::Database;
 
     fn checked_prepare<'db>(database: &'db Database, sql: &str) -> Statement<'db> {
         match database.prepare(sql, &None) {
@@ -108,7 +112,7 @@ mod tests {
     }
 
     fn checked_open() -> Database {
-        match open(":memory:") {
+        match super::open(":memory:") {
             Ok(database) => database,
             Err(ref e) => fail!(e.to_str()),
         }
@@ -323,8 +327,8 @@ mod tests {
 
     #[test]
     fn check_complete_sql() {
-        let r1 = sqlite_complete("SELECT * FROM");
-        let r2 = sqlite_complete("SELECT * FROM bob;");
+        let r1 = super::sqlite_complete("SELECT * FROM");
+        let r2 = super::sqlite_complete("SELECT * FROM bob;");
         assert!(is_ok_and(r1, false));
         assert!(is_ok_and(r2, true));