core::Wormhole: Remove deprecated methods

Author: felinira

src/core.rs

@@ -74,21 +74,6 @@ impl From<std::convert::Infallible> for WormholeError {
     }
 }
 
-/**
- * The result of the client-server handshake
- */
-#[derive(Clone, Debug, PartialEq, Eq)]
-#[deprecated(
-    since = "0.7.0",
-    note = "part of the response of `Wormhole::connect_without_code(...)` and `Wormhole::connect_with_code(...) please use 'MailboxConnection::create(...)`/`MailboxConnection::connect(..)` and `Wormhole::connect(mailbox_connection)' instead"
-)]
-pub struct WormholeWelcome {
-    /** A welcome message from the server (think of "message of the day"). Should be displayed to the user if present. */
-    pub welcome: Option<String>,
-    /// The wormhole code used in the exchange
-    pub code: Code,
-}
-
 /**
  * Establishing Wormhole connection
  *
@@ -310,62 +295,6 @@ pub struct Wormhole {
 }
 
 impl Wormhole {
-    /**
-     * Generate a code and connect to the rendezvous server.
-     *
-     * # Returns
-     *
-     * A tuple with a [`WormholeWelcome`] and a [`std::future::Future`] that will
-     * do the rest of the client-client handshake and yield the [`Wormhole`] object
-     * on success.
-     */
-    #[deprecated(
-        since = "0.7.0",
-        note = "please use 'MailboxConnection::create(..) and Wormhole::connect(mailbox_connection)' instead"
-    )]
-    #[expect(deprecated)]
-    pub async fn connect_without_code(
-        config: AppConfig<impl serde::Serialize + Send + Sync + 'static>,
-        code_length: usize,
-    ) -> Result<
-        (
-            WormholeWelcome,
-            impl std::future::Future<Output = Result<Self, WormholeError>>,
-        ),
-        WormholeError,
-    > {
-        let mailbox_connection = MailboxConnection::create(config, code_length).await?;
-        Ok((
-            WormholeWelcome {
-                welcome: mailbox_connection.welcome.clone(),
-                code: mailbox_connection.code.clone(),
-            },
-            Self::connect(mailbox_connection),
-        ))
-    }
-
-    /**
-     * Connect to a peer with a code.
-     */
-    #[deprecated(
-        since = "0.7.0",
-        note = "please use 'MailboxConnection::connect(..) and Wormhole::connect(mailbox_connection)' instead"
-    )]
-    #[expect(deprecated)]
-    pub async fn connect_with_code(
-        config: AppConfig<impl serde::Serialize + Send + Sync + 'static>,
-        code: Code,
-    ) -> Result<(WormholeWelcome, Self), WormholeError> {
-        let mailbox_connection = MailboxConnection::connect(config, code.clone(), true).await?;
-        Ok((
-            WormholeWelcome {
-                welcome: mailbox_connection.welcome.clone(),
-                code,
-            },
-            Self::connect(mailbox_connection).await?,
-        ))
-    }
-
     /// Set up a Wormhole which is the client-client part of the connection setup
     ///
     /// The MailboxConnection already contains a rendezvous server with an opened mailbox.

src/core/test.rs

@@ -227,95 +227,6 @@ async fn file_offers(
     ])
 }
 
-/** Send a file using the Rust implementation (using deprecated API). This does not guarantee compatibility with Python! ;) */
-#[cfg(feature = "transfer")]
-#[test(async_std::test)]
-// TODO Wasm test disabled, it crashes
-// #[cfg_attr(target_arch = "wasm32", test(wasm_bindgen_test::wasm_bindgen_test))]
-#[expect(deprecated)]
-pub async fn test_file_rust2rust_deprecated() {
-    for (offer, answer) in file_offers().await.unwrap() {
-        let (code_tx, code_rx) = futures::channel::oneshot::channel();
-
-        let sender_task = async_std::task::Builder::new()
-            .name("sender".to_owned())
-            .local(async {
-                let (welcome, wormhole_future) = crate::Wormhole::connect_without_code(
-                    transfer::APP_CONFIG.id(TEST_APPID).clone(),
-                    2,
-                )
-                .await?;
-                if let Some(welcome) = &welcome.welcome {
-                    tracing::info!("Got welcome: {}", welcome);
-                }
-                tracing::info!("This wormhole's code is: {}", &welcome.code);
-                code_tx.send(welcome.code.clone()).unwrap();
-                let wormhole = wormhole_future.await?;
-                eyre::Result::<_>::Ok(
-                    transfer::send(
-                        wormhole,
-                        default_relay_hints(),
-                        magic_wormhole::transit::Abilities::ALL_ABILITIES,
-                        offer,
-                        &log_transit_connection,
-                        |_sent, _total| {},
-                        futures::future::pending(),
-                    )
-                    .await?,
-                )
-            })
-            .unwrap();
-        let receiver_task = async_std::task::Builder::new()
-            .name("receiver".to_owned())
-            .local(async {
-                let code = code_rx.await?;
-                let config = transfer::APP_CONFIG.id(TEST_APPID);
-                tracing::info!("Got code over local: {}", &code);
-                let (welcome, wormhole) =
-                    crate::Wormhole::connect_with_code(config.clone(), code).await?;
-                if let Some(welcome) = &welcome.welcome {
-                    tracing::info!("Got welcome: {}", welcome);
-                }
-
-                // Hacky v1-compat conversion for now
-                let mut answer =
-                    (answer.into_iter_files().next().unwrap().1.content)(false).await?;
-
-                /*let transfer::ReceiveRequest::V1(req) = transfer::request(
-                    wormhole,
-                    default_relay_hints(),
-                    magic_wormhole::transit::Abilities::ALL_ABILITIES,
-                    futures::future::pending(),
-                )
-                .await?
-                .unwrap() else {
-                    panic!("v2 should be disabled for now")
-                };*/
-                let req = transfer::request_file(
-                    wormhole,
-                    default_relay_hints(),
-                    magic_wormhole::transit::Abilities::ALL_ABILITIES,
-                    futures::future::pending(),
-                )
-                .await?
-                .unwrap();
-
-                req.accept(
-                    &log_transit_connection,
-                    |_received, _total| {},
-                    &mut answer,
-                    futures::future::pending(),
-                )
-                .await?;
-                eyre::Result::<_>::Ok(())
-            })
-            .unwrap();
-
-        sender_task.await.unwrap();
-        receiver_task.await.unwrap();
-    }
-}
-
 /** Send a file using the Rust implementation. This does not guarantee compatibility with Python! ;) */
 #[cfg(feature = "transfer")]
 #[test(async_std::test)]

src/lib.rs

@@ -36,11 +36,10 @@ pub mod transit;
 #[cfg(feature = "transfer")]
 pub mod uri;
 
-#[expect(deprecated)]
 pub use crate::core::{
     key::{Key, KeyPurpose, WormholeKey},
     rendezvous, AppConfig, AppID, Code, MailboxConnection, Mood, Nameplate, ParseCodeError,
-    ParseNameplateError, ParsePasswordError, Password, Wormhole, WormholeError, WormholeWelcome,
+    ParseNameplateError, ParsePasswordError, Password, Wormhole, WormholeError,
 };
 
 #[doc(hidden)]