Update sqlx and refinery to newer versions

For some reason, also required rewriting database tests to deal with
tempfile deleting files after scope drop. This never used to occur,
but now it does! So now the unit tests are in a closure where the temp
file is dropped at the end of the test. Really should just use sqlx
migrations, then we can get an in-memory database.

Cargo.lock

@@ -50,23 +50,6 @@ dependencies = [
  "subtle",
 ]
 
-[[package]]
-name = "ahash"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "739f4a8db6605981345c5654f3a85b056ce52f37a39d34da03f25bf2151ea16e"
-
-[[package]]
-name = "ahash"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "796540673305a66d127804eef19ad696f1f204b8c1025aaca4958c17eab32877"
-dependencies = [
- "getrandom 0.2.3",
- "once_cell",
- "version_check",
-]
-
 [[package]]
 name = "ahash"
 version = "0.7.4"
@@ -234,12 +217,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "build_const"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ae4235e6dac0694637c763029ecea1a2ec9e4e06ec2729bd21ba4d9c863eb7"
-
 [[package]]
 name = "bumpalo"
 version = "3.7.0"
@@ -408,13 +385,19 @@ dependencies = [
 
 [[package]]
 name = "crc"
-version = "1.8.1"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d663548de7f5cca343f1e0a48d14dcfb0e9eb4e079ec58883b7251539fa10aeb"
+checksum = "10c2722795460108a7872e1cd933a85d6ec38abc4baecad51028f702da28889f"
 dependencies = [
- "build_const",
+ "crc-catalog",
 ]
 
+[[package]]
+name = "crc-catalog"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccaeedb56da03b09f598226e25e80088cb4cd25f316e6e4df7d695f0feeb1403"
+
 [[package]]
 name = "crc32fast"
 version = "1.2.1"
@@ -741,6 +724,17 @@ dependencies = [
  "futures-util",
 ]
 
+[[package]]
+name = "futures-intrusive"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62007592ac46aa7c2b6416f7deb9a8a8f63a01e0f1d6e1787d5630170db2b63e"
+dependencies = [
+ "futures-core",
+ "lock_api",
+ "parking_lot",
+]
+
 [[package]]
 name = "futures-io"
 version = "0.3.17"
@@ -940,9 +934,6 @@ name = "hashbrown"
 version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7afe4a420e3fe79967a00898cc1f4db7c8a49a9333a29f8a4bd76a253d5cd04"
-dependencies = [
- "ahash 0.4.7",
-]
 
 [[package]]
 name = "hashbrown"
@@ -950,16 +941,16 @@ version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
 dependencies = [
- "ahash 0.7.4",
+ "ahash",
 ]
 
 [[package]]
 name = "hashlink"
-version = "0.6.0"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d99cf782f0dc4372d26846bec3de7804ceb5df083c2d4462c0b8d2330e894fa8"
+checksum = "7249a3129cbc1ffccd74857f81464a323a152173cdb134e0fd81bc803b29facf"
 dependencies = [
- "hashbrown 0.9.1",
+ "hashbrown 0.11.2",
 ]
 
 [[package]]
@@ -1239,9 +1230,9 @@ checksum = "3cb00336871be5ed2c8ed44b60ae9959dc5b9f08539422ed43f09e34ecaeba21"
 
 [[package]]
 name = "libsqlite3-sys"
-version = "0.20.1"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64d31059f22935e6c31830db5249ba2b7ecd54fd73a9909286f0a67aa55c2fbd"
+checksum = "290b64917f8b0cb885d9de0f9959fe1f775d7fa12f1da2db9001c1c8ab60f89d"
 dependencies = [
  "cc",
  "pkg-config",
@@ -2150,9 +2141,9 @@ dependencies = [
 
 [[package]]
 name = "refinery"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e29bd9c881127d714f4b5b9fdd9ea7651f3dd254922e959a10f6ada620e841da"
+checksum = "9f3a3d4976479c5e9a50352cf9117896b581c939e81f4169295cb9b353d30bc8"
 dependencies = [
  "refinery-core",
  "refinery-macros",
@@ -2160,9 +2151,9 @@ dependencies = [
 
 [[package]]
 name = "refinery-core"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53260bc01535ea10c553ce0fc410609ba2dc0a9f4c9b4503e0af842dd4a6f89d"
+checksum = "1eb7989daaee90c44763f644bfa2c3ce46b0a241b9966c1c2be9e65b4918815b"
 dependencies = [
  "async-trait",
  "cfg-if",
@@ -2181,9 +2172,9 @@ dependencies = [
 
 [[package]]
 name = "refinery-macros"
-version = "0.5.0"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a79ff62c9b674b62c06a09cc8becf06cbafba9952afa1d8174e7e15f2c4ed43"
+checksum = "1e2d142a0c173f7e096ae1297d677cb4bb056fc80f25f31d6b0d2a82da07beee"
 dependencies = [
  "proc-macro2 1.0.29",
  "quote 1.0.9",
@@ -2498,9 +2489,9 @@ dependencies = [
 
 [[package]]
 name = "rusqlite"
-version = "0.24.2"
+version = "0.25.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38ee71cbab2c827ec0ac24e76f82eca723cee92c509a65f67dee393c25112"
+checksum = "57adcf67c8faaf96f3248c2a7b419a0dbc52ebe36ba83dd57fe83827c1ea4eb3"
 dependencies = [
  "bitflags",
  "fallible-iterator",
@@ -2768,9 +2759,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx"
-version = "0.5.1"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2739d54a2ae9fdd0f545cb4e4b5574efb95e2ec71b7f921678e246fb20dcaaf"
+checksum = "0e4b94ab0f8c21ee4899b93b06451ef5d965f1a355982ee73684338228498440"
 dependencies = [
  "sqlx-core",
  "sqlx-macros",
@@ -2778,11 +2769,11 @@ dependencies = [
 
 [[package]]
 name = "sqlx-core"
-version = "0.5.1"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1cad9cae4ca8947eba1a90e8ec7d3c59e7a768e2f120dc9013b669c34a90711"
+checksum = "ec28b91a01e1fe286d6ba66f68289a2286df023fc97444e1fd86c2fd6d5dc026"
 dependencies = [
- "ahash 0.6.3",
+ "ahash",
  "atoi",
  "bitflags",
  "byteorder",
@@ -2794,6 +2785,7 @@ dependencies = [
  "either",
  "futures-channel",
  "futures-core",
+ "futures-intrusive",
  "futures-util",
  "hashlink",
  "hex",
@@ -2819,9 +2811,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-macros"
-version = "0.5.1"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01caee2b3935b4efe152f3262afbe51546ce3b1fc27ad61014e1b3cf5f55366e"
+checksum = "4dc33c35d54774eed73d54568d47a6ac099aed8af5e1556a017c131be88217d5"
 dependencies = [
  "dotenv",
  "either",
@@ -2842,9 +2834,9 @@ dependencies = [
 
 [[package]]
 name = "sqlx-rt"
-version = "0.3.0"
+version = "0.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ce2e16b6774c671cc183e1d202386fdf9cde1e8468c1894a7f2a63eb671c4f4"
+checksum = "14302b678d9c76b28f2e60115211e25e0aabc938269991745a169753dc00e35c"
 dependencies = [
  "native-tls",
  "once_cell",

dicebot/Cargo.toml

@@ -33,14 +33,14 @@ futures = "0.3"
 html2text = "0.2"
 phf = { version = "0.8", features = ["macros"] }
 matrix-sdk = { version = "0.3" }
-refinery = { version = "0.5", features = ["rusqlite"]}
+refinery = { version = "0.6", features = ["rusqlite"]}
 barrel = { version = "0.6", features = ["sqlite3"] }
 tempfile = "3"
 substring = "1.4"
 fuse-rust = "0.2"
 tonic = "0.4"
 prost = "0.7"
-tenebrous-rpc = { path = "../rpc" }
+tenebrous-rpc = { path = "../rpc", version = "0.1.0" }
 
 [dependencies.sqlx]
 version = "0.5"

dicebot/src/db/sqlite/rooms.rs

@@ -53,22 +53,27 @@ impl Rooms for Database {
 mod tests {
     use crate::db::sqlite::Database;
     use crate::db::Rooms;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn should_process_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let first_check = db
                 .should_process("myroom", "myeventid")
                 .await
@@ -82,5 +87,7 @@ mod tests {
                 .expect("should_process failed in first insert");
 
             assert_eq!(second_check, false);
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/state.rs

@@ -37,22 +37,27 @@ impl DbState for Database {
 mod tests {
     use crate::db::sqlite::Database;
     use crate::db::DbState;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn set_and_get_device_id() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             db.set_device_id("device_id")
                 .await
                 .expect("Could not set device ID");
@@ -61,19 +66,22 @@ mod tests {
 
             assert!(device_id.is_some());
             assert_eq!(device_id.unwrap(), "device_id");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn no_device_id_set_returns_none() {
-        let db = create_db().await;
+        with_db(|db| async move {
             let device_id = db.get_device_id().await.expect("Could not get device ID");
             assert!(device_id.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_update_device_id() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             db.set_device_id("device_id")
                 .await
                 .expect("Could not set device ID");
@@ -86,5 +94,7 @@ mod tests {
 
             assert!(device_id.is_some());
             assert_eq!(device_id.unwrap(), "device_id2");
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/users.rs

@@ -91,22 +91,27 @@ mod tests {
     use crate::db::sqlite::Database;
     use crate::db::Users;
     use crate::models::AccountStatus;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn create_and_get_full_user_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -129,12 +134,13 @@ mod tests {
             assert_eq!(user.password, Some("abc".to_string()));
             assert_eq!(user.account_status, AccountStatus::Registered);
             assert_eq!(user.active_room, Some("myroom".to_string()));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_get_user_with_no_state_record() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -164,12 +170,13 @@ mod tests {
 
             //These should be default values because the state record is missing.
             assert_eq!(user.active_room, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_insert_without_password() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -189,12 +196,13 @@ mod tests {
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
             assert_eq!(user.password, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_insert_without_active_room() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -214,12 +222,13 @@ mod tests {
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
             assert_eq!(user.active_room, None);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_update_user() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result1 = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -254,12 +263,13 @@ mod tests {
             assert_eq!(user.password, Some("123".to_string()));
             assert_eq!(user.active_room, Some("room".to_string()));
             assert_eq!(user.account_status, AccountStatus::AwaitingActivation);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn can_delete_user() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
@@ -280,27 +290,32 @@ mod tests {
                 .expect("User retrieval query failed");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn username_not_in_db_returns_none() {
-        let db = create_db().await;
+        with_db(|db| async move {
             let user = db
                 .get_user("does not exist")
                 .await
                 .expect("Get user query failure");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn authenticate_user_is_some_with_valid_password() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
-                password: Some(crate::logic::hash_password("abc").expect("password hash error!")),
+                    password: Some(
+                        crate::logic::hash_password("abc").expect("password hash error!"),
+                    ),
                     ..Default::default()
                 })
                 .await;
@@ -315,16 +330,19 @@ mod tests {
             assert!(user.is_some());
             let user = user.unwrap();
             assert_eq!(user.username, "myuser");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn authenticate_user_is_none_with_wrong_password() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let insert_result = db
                 .upsert_user(&User {
                     username: "myuser".to_string(),
-                password: Some(crate::logic::hash_password("abc").expect("password hash error!")),
+                    password: Some(
+                        crate::logic::hash_password("abc").expect("password hash error!"),
+                    ),
                     ..Default::default()
                 })
                 .await;
@@ -337,5 +355,7 @@ mod tests {
                 .expect("User retrieval query failed");
 
             assert!(user.is_none());
+        })
+        .await;
     }
 }

dicebot/src/db/sqlite/variables.rs

@@ -102,22 +102,27 @@ mod tests {
     use super::*;
     use crate::db::sqlite::Database;
     use crate::db::Variables;
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn set_and_get_variable_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             db.set_user_variable("myuser", "myroom", "myvariable", 1)
                 .await
                 .expect("Could not set variable");
@@ -128,12 +133,13 @@ mod tests {
                 .expect("Could not get variable");
 
             assert_eq!(value, 1);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_missing_variable_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let value = db.get_user_variable("myuser", "myroom", "myvariable").await;
 
             assert!(value.is_err());
@@ -141,12 +147,13 @@ mod tests {
                 value.err().unwrap(),
                 DataError::KeyDoesNotExist(_)
             ));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_other_user_variable_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             db.set_user_variable("myuser1", "myroom", "myvariable", 1)
                 .await
                 .expect("Could not set variable");
@@ -160,12 +167,13 @@ mod tests {
                 value.err().unwrap(),
                 DataError::KeyDoesNotExist(_)
             ));
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "myroom", variable_name, 1)
                     .await
@@ -178,12 +186,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 3);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_respects_user_id() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("different-user", "myroom", variable_name, 1)
                     .await
@@ -196,12 +205,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 0);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn count_variables_respects_room_id() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "different-room", variable_name, 1)
                     .await
@@ -214,12 +224,13 @@ mod tests {
                 .expect("Could not get count.");
 
             assert_eq!(count, 0);
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn delete_variable_test() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             for variable_name in &["var1", "var2", "var3"] {
                 db.set_user_variable("myuser", "myroom", variable_name, 1)
                     .await
@@ -240,5 +251,7 @@ mod tests {
             let var1 = db.get_user_variable("myuser", "myroom", "var1").await;
             assert!(var1.is_err());
             assert!(matches!(var1.err().unwrap(), DataError::KeyDoesNotExist(_)));
+        })
+        .await;
     }
 }

dicebot/src/logic.rs

@@ -71,22 +71,27 @@ mod tests {
     use super::*;
     use crate::db::Users;
     use crate::models::{AccountStatus, User};
+    use std::future::Future;
 
-    async fn create_db() -> Database {
+    async fn with_db<Fut>(f: impl FnOnce(Database) -> Fut)
+    where
+        Fut: Future<Output = ()>,
+    {
         let db_path = tempfile::NamedTempFile::new_in(".").unwrap();
         crate::db::sqlite::migrator::migrate(db_path.path().to_str().unwrap())
             .await
             .unwrap();
 
-        Database::new(db_path.path().to_str().unwrap())
+        let db = Database::new(db_path.path().to_str().unwrap())
             .await
-            .unwrap()
+            .unwrap();
+
+        f(db).await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_account_no_user_exists() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let account = get_account(&db, "@test:example.com")
                 .await
                 .expect("Account retrieval didn't work");
@@ -95,12 +100,13 @@ mod tests {
 
             let user = account.transient_user().unwrap();
             assert_eq!(user.username, "@test:example.com");
+        })
+        .await;
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
     async fn get_or_create_user_when_user_exists() {
-        let db = create_db().await;
+        with_db(|db| async move {
-
             let user = User {
                 username: "myuser".to_string(),
                 password: Some("abc".to_string()),
@@ -119,5 +125,7 @@ mod tests {
 
             let user_again = account.registered_user().unwrap();
             assert_eq!(user, *user_again);
+        })
+        .await;
     }
 }

rpc/src/main.rs

@@ -1,3 +0,0 @@
-fn main() {
-    println!("Hello, world!");
-}