diff --git a/Cargo.lock b/Cargo.lock index 80f0b570..928246ed 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -174,12 +174,6 @@ dependencies = [ "serde", ] -[[package]] -name = "bumpalo" -version = "3.20.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb" - [[package]] name = "bytes" version = "1.11.1" @@ -188,9 +182,9 @@ checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33" [[package]] name = "cc" -version = "1.2.58" +version = "1.2.60" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1e928d4b69e3077709075a938a05ffbedfa53a84c8f766efbf8220bb1ff60e1" +checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20" dependencies = [ "find-msvc-tools", "jobserver", @@ -198,12 +192,6 @@ dependencies = [ "shlex", ] -[[package]] -name = "cesu8" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" - [[package]] name = "cfg-if" version = "1.0.4" @@ -250,8 +238,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0e82d74e6c83060ec269fe9e0d408d6de4a1645d525f9a0bbbb841ba4efd91ac" dependencies = [ "hashbrown 0.15.5", - "regex-automata 0.3.9", - "serde", "unicode-ident", "unicode-segmentation", ] @@ -281,9 +267,9 @@ dependencies = [ [[package]] name = "clap_complete" -version = "4.6.0" +version = "4.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "19c9f1dde76b736e3681f28cec9d5a61299cbaae0fce80a68e43724ad56031eb" +checksum = "3ff7a1dccbdd8b078c2bdebff47e404615151534d5043da397ec50286816f9cb" dependencies = [ "clap", ] @@ -308,9 +294,9 @@ checksum = "c8d4a3bb8b1e0c1050499d1815f5ab16d04f0959b233085fb31653fbfc9d98f9" [[package]] name = "clap_mangen" -version = "0.2.33" +version = "0.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e30ffc187e2e3aeafcd1c6e2aa416e29739454c0ccaa419226d5ecd181f2d78" +checksum = "d82842b45bf9f6a3be090dd860095ac30728042c08e0d6261ca7259b5d850f07" dependencies = [ "clap", "roff", @@ -503,9 +489,9 @@ dependencies = [ [[package]] name = "fastrand" -version = "2.3.0" +version = "2.4.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be" +checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6" [[package]] name = "find-msvc-tools" @@ -621,9 +607,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.16.1" +version = "0.17.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100" +checksum = "4f467dd6dccf739c208452f8014c75c18bb8301b050ad1cfb27153803edb0f51" [[package]] name = "hashify" @@ -661,7 +647,7 @@ dependencies = [ "io-maildir", "io-process", "io-smtp", - "io-stream", + "io-socket", "log", "mail-parser", "mime_guess", @@ -677,16 +663,6 @@ dependencies = [ "url", ] -[[package]] -name = "http" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a" -dependencies = [ - "bytes", - "itoa", -] - [[package]] name = "httparse" version = "1.10.1" @@ -827,84 +803,83 @@ dependencies = [ "bounded-static-derive", "chrono", "rand", - "thiserror 2.0.18", + "thiserror", ] [[package]] name = "indexmap" -version = "2.13.0" +version = "2.14.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017" +checksum = "d466e9454f08e4a911e14806c24e16fba1b4c121d1ea474396f396069cf949d9" dependencies = [ "equivalent", - "hashbrown 0.16.1", + "hashbrown 0.17.0", "serde", "serde_core", ] [[package]] name = "io-fs" -version = "0.0.1" -source = "git+https://github.com/pimalaya/io-fs#6c2305c52fdd5ec9ed05e902183fdf2942ea0590" +version = "0.0.2" +source = "git+https://github.com/pimalaya/io-fs#96cfd6cf4c058dec430a993b893ecaa6bcf40901" dependencies = [ "log", - "thiserror 2.0.18", + "thiserror", ] [[package]] name = "io-http" version = "0.0.3" -source = "git+https://github.com/pimalaya/io-http#4123d10e62a05245c19292f1c88cf0f3ef24f4fc" +source = "git+https://github.com/pimalaya/io-http#898a841b009ba133ac5242a8456fc3138bf05311" dependencies = [ - "http", + "base64", "httparse", - "io-stream", + "io-socket", "log", "memchr", - "thiserror 2.0.18", + "secrecy", + "thiserror", + "url", ] [[package]] name = "io-imap" version = "0.0.1" -source = "git+https://github.com/pimalaya/io-imap?branch=io#32ca082c281da619ae008be17966c73e4e3f6c57" +source = "git+https://github.com/pimalaya/io-imap?branch=io#f6a8ce517740d2922b310203658cd494b759d70f" dependencies = [ "imap-codec", - "io-stream", + "io-socket", "log", - "memchr", "secrecy", - "thiserror 2.0.18", + "thiserror", ] [[package]] name = "io-jmap" version = "0.0.1" -source = "git+https://github.com/pimalaya/io-jmap#a66fd5098c97413dd964b0e466a5d14569727fac" +source = "git+https://github.com/pimalaya/io-jmap#facc39bd8d18fbe5957e948980aded750abd45fd" dependencies = [ - "http", "io-http", - "io-stream", + "io-socket", "log", "secrecy", "serde", "serde_json", - "thiserror 2.0.18", + "thiserror", "url", ] [[package]] name = "io-maildir" version = "0.0.1" -source = "git+https://github.com/pimalaya/io-maildir#75e5b0dc4fd8ce7ac71578f22f5fb2d89831efac" +source = "git+https://github.com/pimalaya/io-maildir#86b9d82a0a4332993dca084e2f2fe0c54534b9f0" dependencies = [ "gethostname", "io-fs", "log", "mail-parser", "memchr", - "thiserror 2.0.18", - "uuid", + "thiserror", ] [[package]] @@ -917,32 +892,31 @@ dependencies = [ "log", "serde", "shellexpand", - "thiserror 2.0.18", + "thiserror", ] [[package]] name = "io-smtp" version = "0.0.1" -source = "git+https://github.com/pimalaya/io-smtp#746df6918b8cfd134c1096fed62927ad2166ad13" +source = "git+https://github.com/pimalaya/io-smtp#d80b9961f874149a65f8fc3084c4b7ac187e7c81" dependencies = [ "base64", "bounded-static", "bounded-static-derive", "chumsky 1.0.0-alpha.8", - "io-stream", + "io-socket", "log", "secrecy", - "thiserror 2.0.18", + "thiserror", ] [[package]] -name = "io-stream" -version = "0.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "28001902240f3f1c95cd165933ec130068e82c1b0118157bbf20f8be0054041f" +name = "io-socket" +version = "0.0.1" +source = "git+https://github.com/pimalaya/io-socket#5899582a02a2bde78a4c92e5a2ed2f2cfea54c29" dependencies = [ "log", - "thiserror 2.0.18", + "thiserror", ] [[package]] @@ -1002,27 +976,32 @@ dependencies = [ [[package]] name = "jni" -version = "0.21.1" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a87aa2bb7d2af34197c04845522473242e1aa17c12f4935d5856491a7fb8c97" +checksum = "5efd9a482cf3a427f00d6b35f14332adc7902ce91efb778580e180ff90fa3498" dependencies = [ - "cesu8", "cfg-if", "combine", - "jni-sys 0.3.1", + "jni-macros", + "jni-sys", "log", - "thiserror 1.0.69", + "simd_cesu8", + "thiserror", "walkdir", - "windows-sys 0.45.0", + "windows-link", ] [[package]] -name = "jni-sys" -version = "0.3.1" +name = "jni-macros" +version = "0.22.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41a652e1f9b6e0275df1f15b32661cf0d4b78d4d87ddec5e0c3c20f097433258" +checksum = "a00109accc170f0bdb141fed3e393c565b6f5e072365c3bd58f5b062591560a3" dependencies = [ - "jni-sys 0.4.1", + "proc-macro2", + "quote", + "rustc_version", + "simd_cesu8", + "syn", ] [[package]] @@ -1054,16 +1033,6 @@ dependencies = [ "libc", ] -[[package]] -name = "js-sys" -version = "0.3.94" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2e04e2ef80ce82e13552136fabeef8a5ed1f985a96805761cbb9a2c34e7664d9" -dependencies = [ - "once_cell", - "wasm-bindgen", -] - [[package]] name = "leb128fmt" version = "0.1.0" @@ -1072,9 +1041,9 @@ checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2" [[package]] name = "libc" -version = "0.2.184" +version = "0.2.185" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48f5d2a454e16a5ea0f4ced81bd44e4cfc7bd3a507b61887c99fd3538b28e4af" +checksum = "52ff2c0fe9bc6cb6b14a0592c2ff4fa9ceb83eea9db979b0487cd054946a2b8f" [[package]] name = "libgit2-sys" @@ -1090,18 +1059,18 @@ dependencies = [ [[package]] name = "libredox" -version = "0.1.15" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ddbf48fd451246b1f8c2610bd3b4ac0cc6e149d89832867093ab69a17194f08" +checksum = "e02f3bb43d335493c96bf3fd3a321600bf6bd07ed34bc64118e9293bdffea46c" dependencies = [ "libc", ] [[package]] name = "libz-sys" -version = "1.1.25" +version = "1.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d52f4c29e2a68ac30c9087e1b772dc9f44a2b66ed44edf2266cf2be9b03dafc1" +checksum = "fc3a226e576f50782b3305c5ccf458698f92798987f551c6a02efe8276721e22" dependencies = [ "cc", "libc", @@ -1259,9 +1228,9 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.76" +version = "0.10.77" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "951c002c75e16ea2c65b8c7e4d3d51d5530d8dfa7d060b4776828c88cfb18ecf" +checksum = "bfe4646e360ec77dff7dde40ed3d6c5fee52d156ef4a62f53973d38294dad87f" dependencies = [ "bitflags", "cfg-if", @@ -1291,18 +1260,18 @@ checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe" [[package]] name = "openssl-src" -version = "300.5.5+3.5.5" +version = "300.6.0+3.6.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f1787d533e03597a7934fd0a765f0d28e94ecc5fb7789f8053b1e699a56f709" +checksum = "a8e8cbfd3a4a8c8f089147fd7aaa33cf8c7450c4d09f8f80698a0cf093abeff4" dependencies = [ "cc", ] [[package]] name = "openssl-sys" -version = "0.9.112" +version = "0.9.113" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57d55af3b3e226502be1526dfdba67ab0e9c96fc293004e79576b2b9edb0dbdb" +checksum = "ad2f2c0eba47118757e4c6d2bff2838f3e0523380021356e7875e858372ce644" dependencies = [ "cc", "libc", @@ -1355,7 +1324,7 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220" [[package]] name = "pimalaya-toolbox" version = "0.0.4" -source = "git+https://github.com/pimalaya/toolbox#68667caa612fb6eeae78fa044b0e79f35c4b4bcf" +source = "git+https://github.com/pimalaya/toolbox#60ec858fbcdc8f048c15eb54a711d80eadebcf20" dependencies = [ "anyhow", "base64", @@ -1370,7 +1339,7 @@ dependencies = [ "io-jmap", "io-process", "io-smtp", - "io-stream", + "io-socket", "log", "native-tls", "rustls", @@ -1380,7 +1349,7 @@ dependencies = [ "serde-toml-merge", "serde_json", "shellexpand", - "thiserror 2.0.18", + "thiserror", "toml", "uds_windows", "url", @@ -1388,9 +1357,9 @@ dependencies = [ [[package]] name = "pkg-config" -version = "0.3.32" +version = "0.3.33" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c" +checksum = "19f132c84eca552bf34cab8ec81f1c1dcc229b811638f9d283dceabe58c5569e" [[package]] name = "portable-atomic" @@ -1555,7 +1524,7 @@ checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac" dependencies = [ "getrandom 0.2.17", "libredox", - "thiserror 2.0.18", + "thiserror", ] [[package]] @@ -1615,7 +1584,7 @@ dependencies = [ "chumsky 0.12.0", "memchr", "quoted_printable", - "thiserror 2.0.18", + "thiserror", ] [[package]] @@ -1638,6 +1607,15 @@ version = "1.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "323c417e1d9665a65b263ec744ba09030cfb277e9daa0b018a4ab62e57bc8189" +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + [[package]] name = "rustix" version = "1.1.4" @@ -1653,9 +1631,9 @@ dependencies = [ [[package]] name = "rustls" -version = "0.23.37" +version = "0.23.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "758025cb5fccfd3bc2fd74708fd4682be41d99e5dff73c377c0646c6012c73a4" +checksum = "69f9466fb2c14ea04357e91413efb882e2a6d4a406e625449bc0a5d360d53a21" dependencies = [ "aws-lc-rs", "log", @@ -1690,9 +1668,9 @@ dependencies = [ [[package]] name = "rustls-platform-verifier" -version = "0.6.2" +version = "0.7.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784" +checksum = "26d1e2536ce4f35f4846aa13bff16bd0ff40157cdb14cc056c7b14ba41233ba0" dependencies = [ "core-foundation", "core-foundation-sys", @@ -1717,9 +1695,9 @@ checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f" [[package]] name = "rustls-webpki" -version = "0.103.10" +version = "0.103.11" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df33b2b81ac578cabaf06b89b0631153a3f416b0a886e8a7a1707fb51abbd1ef" +checksum = "20a6af516fea4b20eccceaf166e8aa666ac996208e8a644ce3ef5aa783bc7cd4" dependencies = [ "aws-lc-rs", "ring", @@ -1727,12 +1705,6 @@ dependencies = [ "untrusted", ] -[[package]] -name = "rustversion" -version = "1.0.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d" - [[package]] name = "same-file" version = "1.0.6" @@ -1792,9 +1764,9 @@ dependencies = [ [[package]] name = "semver" -version = "1.0.27" +version = "1.0.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2" +checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd" [[package]] name = "serde" @@ -1872,6 +1844,22 @@ version = "1.3.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64" +[[package]] +name = "simd_cesu8" +version = "1.1.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "94f90157bb87cddf702797c5dadfa0be7d266cdf49e22da2fcaa32eff75b2c33" +dependencies = [ + "rustc_version", + "simdutf8", +] + +[[package]] +name = "simdutf8" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e" + [[package]] name = "smallvec" version = "1.15.1" @@ -1960,33 +1948,13 @@ version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683" -[[package]] -name = "thiserror" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52" -dependencies = [ - "thiserror-impl 1.0.69", -] - [[package]] name = "thiserror" version = "2.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4" dependencies = [ - "thiserror-impl 2.0.18", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1" -dependencies = [ - "proc-macro2", - "quote", - "syn", + "thiserror-impl", ] [[package]] @@ -2123,17 +2091,6 @@ version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821" -[[package]] -name = "uuid" -version = "1.23.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ac8b6f42ead25368cf5b098aeb3dc8a1a2c05a3eee8a9a1a68c640edbfc79d9" -dependencies = [ - "getrandom 0.4.2", - "js-sys", - "wasm-bindgen", -] - [[package]] name = "vcpkg" version = "0.2.15" @@ -2183,51 +2140,6 @@ dependencies = [ "wit-bindgen", ] -[[package]] -name = "wasm-bindgen" -version = "0.2.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0551fc1bb415591e3372d0bc4780db7e587d84e2a7e79da121051c5c4b89d0b0" -dependencies = [ - "cfg-if", - "once_cell", - "rustversion", - "wasm-bindgen-macro", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7fbdf9a35adf44786aecd5ff89b4563a90325f9da0923236f6104e603c7e86be" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dca9693ef2bab6d4e6707234500350d8dad079eb508dca05530c85dc3a529ff2" -dependencies = [ - "bumpalo", - "proc-macro2", - "quote", - "syn", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.117" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "39129a682a6d2d841b6c429d0c51e5cb0ed1a03829d8b3d1e69a011e62cb3d3b" -dependencies = [ - "unicode-ident", -] - [[package]] name = "wasm-encoder" version = "0.244.0" @@ -2308,22 +2220,13 @@ version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5" -[[package]] -name = "windows-sys" -version = "0.45.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0" -dependencies = [ - "windows-targets 0.42.2", -] - [[package]] name = "windows-sys" version = "0.52.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" dependencies = [ - "windows-targets 0.52.6", + "windows-targets", ] [[package]] @@ -2332,7 +2235,7 @@ version = "0.59.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b" dependencies = [ - "windows-targets 0.52.6", + "windows-targets", ] [[package]] @@ -2344,67 +2247,34 @@ dependencies = [ "windows-link", ] -[[package]] -name = "windows-targets" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071" -dependencies = [ - "windows_aarch64_gnullvm 0.42.2", - "windows_aarch64_msvc 0.42.2", - "windows_i686_gnu 0.42.2", - "windows_i686_msvc 0.42.2", - "windows_x86_64_gnu 0.42.2", - "windows_x86_64_gnullvm 0.42.2", - "windows_x86_64_msvc 0.42.2", -] - [[package]] name = "windows-targets" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973" dependencies = [ - "windows_aarch64_gnullvm 0.52.6", - "windows_aarch64_msvc 0.52.6", - "windows_i686_gnu 0.52.6", + "windows_aarch64_gnullvm", + "windows_aarch64_msvc", + "windows_i686_gnu", "windows_i686_gnullvm", - "windows_i686_msvc 0.52.6", - "windows_x86_64_gnu 0.52.6", - "windows_x86_64_gnullvm 0.52.6", - "windows_x86_64_msvc 0.52.6", + "windows_i686_msvc", + "windows_x86_64_gnu", + "windows_x86_64_gnullvm", + "windows_x86_64_msvc", ] -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8" - [[package]] name = "windows_aarch64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3" -[[package]] -name = "windows_aarch64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43" - [[package]] name = "windows_aarch64_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469" -[[package]] -name = "windows_i686_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f" - [[package]] name = "windows_i686_gnu" version = "0.52.6" @@ -2417,48 +2287,24 @@ version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66" -[[package]] -name = "windows_i686_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060" - [[package]] name = "windows_i686_msvc" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66" -[[package]] -name = "windows_x86_64_gnu" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36" - [[package]] name = "windows_x86_64_gnu" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78" -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3" - [[package]] name = "windows_x86_64_gnullvm" version = "0.52.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d" -[[package]] -name = "windows_x86_64_msvc" -version = "0.42.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0" - [[package]] name = "windows_x86_64_msvc" version = "0.52.6" @@ -2564,9 +2410,9 @@ dependencies = [ [[package]] name = "writeable" -version = "0.6.2" +version = "0.6.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9" +checksum = "1ffae5123b2d3fc086436f8834ae3ab053a283cfac8fe0a0b8eaae044768a4c4" [[package]] name = "yoke" diff --git a/Cargo.toml b/Cargo.toml index b2c003eb..8a99226f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -16,7 +16,6 @@ all-features = true rustdoc-args = ["--cfg", "docsrs"] [features] -# default = ["imap", "maildir", "smtp", "rustls-ring"] default = ["imap", "smtp", "rustls-ring"] imap = ["dep:io-imap", "dep:mail-parser", "dep:rfc2047-decoder", "pimalaya-toolbox/imap"] @@ -41,13 +40,13 @@ comfy-table = "7" convert_case = { version = "0.11", optional = true } dirs = "6" gethostname = "1" -io-fs = { version = "0.0.1", default-features = false, features = ["std"], optional = true } +io-fs = { version = "0.0.2", default-features = false, features = ["std"], optional = true } io-imap = { version = "0.0.1", default-features = false, optional = true } io-jmap = { version = "0.0.1", default-features = false, optional = true } io-maildir = { version = "0.0.1", default-features = false, features = ["serde"], optional = true } io-process = { version = "0.0.2", default-features = false } io-smtp = { version = "0.0.1", default-features = false, optional = true } -io-stream = { version = "0.0.2", default-features = false, features = ["std"] } +io-socket = { version = "0.0.1", default-features = false, features = ["std-stream"] } log = "0.4" mail-parser = { version = "0.11", features = ["serde"], optional = true } mime_guess = { version = "2", optional = true } @@ -77,4 +76,5 @@ io-imap = { git = "https://github.com/pimalaya/io-imap", branch = "io" } io-jmap.git = "https://github.com/pimalaya/io-jmap" io-maildir.git = "https://github.com/pimalaya/io-maildir" io-smtp.git = "https://github.com/pimalaya/io-smtp" +io-socket.git = "https://github.com/pimalaya/io-socket" pimalaya-toolbox.git = "https://github.com/pimalaya/toolbox" diff --git a/src/config.rs b/src/config.rs index c80f4aea..0fea6b74 100644 --- a/src/config.rs +++ b/src/config.rs @@ -3,7 +3,7 @@ use std::{collections::HashMap, path::PathBuf}; use comfy_table::ContentArrangement; use pimalaya_toolbox::{ config::{shell_expanded_string, TomlConfig}, - sasl::{sasl_default_mechanisms, Sasl, SaslAnonymous, SaslLogin, SaslMechanism, SaslPlain}, + sasl::{Sasl, SaslAnonymous, SaslLogin, SaslMechanism, SaslPlain}, secret::{Secret, SecretError}, stream::{Rustls, RustlsCrypto, Tls, TlsProvider}, }; @@ -175,18 +175,19 @@ impl TryFrom for Tls { #[derive(Clone, Debug, Default, Deserialize)] #[serde(rename_all = "kebab-case", deny_unknown_fields)] pub struct SaslConfig { - pub mechanisms: Option>, + pub mechanism: Option, pub login: Option, pub plain: Option, pub anonymous: Option, } /// SASL mechanism configuration. -#[derive(Clone, Debug, Deserialize)] +#[derive(Clone, Debug, Default, Deserialize)] #[serde(rename_all = "kebab-case")] pub enum SaslMechanismConfig { Login, Plain, + #[default] Anonymous, } @@ -221,17 +222,11 @@ impl TryFrom for Sasl { fn try_from(config: SaslConfig) -> Result { Ok(Sasl { - mechanisms: match config.mechanisms { - None => sasl_default_mechanisms(), - Some(config) => config - .into_iter() - .map(|m| match m { - SaslMechanismConfig::Anonymous => SaslMechanism::Anonymous, - SaslMechanismConfig::Plain => SaslMechanism::Plain, - SaslMechanismConfig::Login => SaslMechanism::Login, - }) - .collect(), - }, + mechanism: config.mechanism.map(|m| match m { + SaslMechanismConfig::Anonymous => SaslMechanism::Anonymous, + SaslMechanismConfig::Plain => SaslMechanism::Plain, + SaslMechanismConfig::Login => SaslMechanism::Login, + }), anonymous: match config.anonymous { None => None, Some(config) => Some(SaslAnonymous { diff --git a/src/imap/command.rs b/src/imap/command.rs index 3545b10b..52fdb1f8 100644 --- a/src/imap/command.rs +++ b/src/imap/command.rs @@ -3,8 +3,8 @@ use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; use crate::imap::{ - account::ImapAccount, envelope::command::EnvelopeCommand, flag::command::FlagCommand, - id::IdCommand, mailbox::command::MailboxCommand, message::command::MessageCommand, + account::ImapAccount, envelope::command::ImapEnvelopeCommand, flag::command::ImapFlagCommand, + id::ImapIdCommand, mailbox::command::ImapMailboxCommand, message::command::ImapMessageCommand, }; /// IMAP CLI (requires the `imap` cargo feature). @@ -14,18 +14,18 @@ use crate::imap::{ #[derive(Debug, Subcommand)] #[command(rename_all = "kebab-case")] pub enum ImapCommand { - Id(IdCommand), + Id(ImapIdCommand), #[command(subcommand)] #[command(aliases = ["mboxes", "mbox"])] - Mailboxes(MailboxCommand), + Mailboxes(ImapMailboxCommand), #[command(subcommand)] - Envelopes(EnvelopeCommand), + Envelopes(ImapEnvelopeCommand), #[command(subcommand)] - Flags(FlagCommand), + Flags(ImapFlagCommand), #[command(subcommand)] #[command(aliases = ["msgs", "msg"])] - Messages(MessageCommand), + Messages(ImapMessageCommand), } impl ImapCommand { diff --git a/src/imap/envelope/command.rs b/src/imap/envelope/command.rs index 092848a0..95c81d8a 100644 --- a/src/imap/envelope/command.rs +++ b/src/imap/envelope/command.rs @@ -5,8 +5,9 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::imap::{ account::ImapAccount, envelope::{ - get::GetEnvelopeCommand, list::ListEnvelopesCommand, search::SearchEnvelopesCommand, - sort::SortEnvelopesCommand, thread::ThreadEnvelopesCommand, + get::ImapEnvelopeGetCommand, list::ImapEnvelopeListCommand, + search::ImapEnvelopeSearchCommand, sort::ImapEnvelopeSortCommand, + thread::ImapEnvelopeThreadCommand, }, }; @@ -16,15 +17,15 @@ use crate::imap::{ /// date, subject, from, to, cc, bcc, etc. This subcommand allows you /// to get, list, search, sort, and thread envelopes. #[derive(Debug, Subcommand)] -pub enum EnvelopeCommand { - Get(GetEnvelopeCommand), - List(ListEnvelopesCommand), - Search(SearchEnvelopesCommand), - Sort(SortEnvelopesCommand), - Thread(ThreadEnvelopesCommand), +pub enum ImapEnvelopeCommand { + Get(ImapEnvelopeGetCommand), + List(ImapEnvelopeListCommand), + Search(ImapEnvelopeSearchCommand), + Sort(ImapEnvelopeSortCommand), + Thread(ImapEnvelopeThreadCommand), } -impl EnvelopeCommand { +impl ImapEnvelopeCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/imap/envelope/get.rs b/src/imap/envelope/get.rs index ebf320cc..d3b453d2 100644 --- a/src/imap/envelope/get.rs +++ b/src/imap/envelope/get.rs @@ -4,13 +4,13 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, Row, Table}; use io_imap::{ - coroutines::{fetch::*, select::*}, + rfc3501::{fetch::*, select::*}, types::{ core::Vec1, fetch::{MacroOrMessageDataItemNames, MessageDataItem, MessageDataItemName}, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -26,7 +26,7 @@ use crate::imap::{ /// message, including all header fields like date, subject, from, to, /// cc, bcc, reply-to, message-id, and in-reply-to. #[derive(Debug, Parser)] -pub struct GetEnvelopeCommand { +pub struct ImapEnvelopeGetCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -40,20 +40,22 @@ pub struct GetEnvelopeCommand { pub seq: bool, } -impl GetEnvelopeCommand { +impl ImapEnvelopeGetCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -66,13 +68,15 @@ impl GetEnvelopeCommand { MacroOrMessageDataItemNames::MessageDataItemNames(vec![MessageDataItemName::Envelope]); let mut arg = None; - let mut coroutine = ImapFetchFirst::new(imap.context, id, item_names, !self.seq); + let mut coroutine = ImapMessageFetchFirst::new(imap.context, id, item_names, !self.seq); let items = loop { match coroutine.resume(arg.take()) { - ImapFetchFirstResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchFirstResult::Ok { items, .. } => break items, - ImapFetchFirstResult::Err { err, .. } => bail!(err), + ImapMessageFetchFirstResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageFetchFirstResult::Ok { items, .. } => break items, + ImapMessageFetchFirstResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/envelope/list.rs b/src/imap/envelope/list.rs index 48ea1a63..d4ff24e9 100644 --- a/src/imap/envelope/list.rs +++ b/src/imap/envelope/list.rs @@ -1,10 +1,10 @@ -use std::{collections::HashMap, fmt, num::NonZeroU32}; +use std::{collections::BTreeMap, fmt, num::NonZeroU32}; use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, ContentArrangement, Row, Table}; use io_imap::{ - coroutines::{fetch::*, select::*, status::*}, + rfc3501::{fetch::*, select::*, status::*}, types::{ core::Vec1, envelope::Address, @@ -13,7 +13,7 @@ use io_imap::{ status::{StatusDataItem, StatusDataItemName}, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::debug; use pimalaya_toolbox::terminal::printer::Printer; use rfc2047_decoder::{Decoder, RecoverStrategy}; @@ -30,7 +30,7 @@ use crate::imap::{ /// mailbox. You can specify a sequence set to limit which messages /// are fetched. #[derive(Debug, Parser)] -pub struct ListEnvelopesCommand { +pub struct ImapEnvelopeListCommand { /// The sequence set of envelopes. #[arg(value_name = "SEQUENCE")] #[arg(conflicts_with = "page_size")] @@ -53,7 +53,7 @@ pub struct ListEnvelopesCommand { pub sequence: bool, } -impl ListEnvelopesCommand { +impl ImapEnvelopeListCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; @@ -61,33 +61,37 @@ impl ListEnvelopesCommand { let exists = if self.mailbox_no_select.inner { let mut arg = None; let mut coroutine = - ImapStatus::new(imap.context, mailbox, &[StatusDataItemName::Messages]); + ImapMailboxStatus::new(imap.context, mailbox, &[StatusDataItemName::Messages]); loop { match coroutine.resume(arg.take()) { - ImapStatusResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStatusResult::Ok { context, items } => { + ImapMailboxStatusResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxStatusResult::Ok { context, items } => { imap.context = context; break items.into_iter().find_map(|i| match i { StatusDataItem::Messages(exists) => Some(exists), _ => None, }); } - ImapStatusResult::Err { err, .. } => bail!(err), + ImapMailboxStatusResult::Err { err, .. } => bail!(err), } } } else { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, data } => { + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, data } => { imap.context = context; break data.exists; } - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } } }; @@ -110,7 +114,7 @@ impl ListEnvelopesCommand { ]); let mut arg = None; - let mut coroutine = ImapFetch::new( + let mut coroutine = ImapMessageFetch::new( imap.context, sequence_set, item_names, @@ -119,9 +123,11 @@ impl ListEnvelopesCommand { let data = loop { match coroutine.resume(arg.take()) { - ImapFetchResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchResult::Ok { data, .. } => break data, - ImapFetchResult::Err { err, .. } => bail!(err), + ImapMessageFetchResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageFetchResult::Ok { data, .. } => break data, + ImapMessageFetchResult::Err { err, .. } => bail!(err), } }; @@ -185,7 +191,7 @@ pub struct EnvelopesTableEntry { } fn map_envelopes_table_entries( - data: HashMap>>, + data: BTreeMap>>, ) -> Vec { let mut entries: Vec = data .into_iter() diff --git a/src/imap/envelope/search.rs b/src/imap/envelope/search.rs index 2d8b358e..e2239e1c 100644 --- a/src/imap/envelope/search.rs +++ b/src/imap/envelope/search.rs @@ -4,14 +4,14 @@ use anyhow::{anyhow, bail, Result}; use clap::Parser; use comfy_table::{Cell, ContentArrangement, Row, Table}; use io_imap::{ - coroutines::{search::*, select::*}, + rfc3501::{search::*, select::*}, types::{ core::{AString, Vec1}, datetime::NaiveDate, search::SearchKey, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -46,7 +46,7 @@ use crate::imap::{ /// - smaller:5000 - messages smaller than 5000 bytes /// - all - all messages #[derive(Debug, Parser)] -pub struct SearchEnvelopesCommand { +pub struct ImapEnvelopeSearchCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -61,20 +61,22 @@ pub struct SearchEnvelopesCommand { pub seq: bool, } -impl SearchEnvelopesCommand { +impl ImapEnvelopeSearchCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -82,13 +84,15 @@ impl SearchEnvelopesCommand { let criteria = parse_query(&self.query)?; let mut arg = None; - let mut coroutine = ImapSearch::new(imap.context, criteria, !self.seq); + let mut coroutine = ImapMessageSearch::new(imap.context, criteria, !self.seq); let ids = loop { match coroutine.resume(arg.take()) { - ImapSearchResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSearchResult::Ok { ids, .. } => break ids, - ImapSearchResult::Err { err, .. } => bail!(err), + ImapMessageSearchResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageSearchResult::Ok { ids, .. } => break ids, + ImapMessageSearchResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/envelope/sort.rs b/src/imap/envelope/sort.rs index 4ddab3c2..e3b5eff1 100644 --- a/src/imap/envelope/sort.rs +++ b/src/imap/envelope/sort.rs @@ -4,13 +4,14 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{presets, Cell, ContentArrangement, Row, Table}; use io_imap::{ - coroutines::{select::*, sort::*}, + rfc3501::select::*, + rfc5256::sort::*, types::{ core::Vec1, extensions::sort::{SortCriterion, SortKey}, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -33,7 +34,7 @@ use crate::imap::{ /// - subject - sort by Subject header /// - size - sort by message size #[derive(Debug, Parser)] -pub struct SortEnvelopesCommand { +pub struct ImapEnvelopeSortCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalArg, @@ -54,20 +55,22 @@ pub struct SortEnvelopesCommand { pub seq: bool, } -impl SortEnvelopesCommand { +impl ImapEnvelopeSortCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; // SELECT mailbox let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); let context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; @@ -83,13 +86,14 @@ impl SortEnvelopesCommand { // SORT let mut arg = None; - let mut coroutine = ImapSort::new(context, sort_criteria, search_criteria, !self.seq); + let mut coroutine = + ImapMailboxSort::new(context, sort_criteria, search_criteria, !self.seq); let ids = loop { match coroutine.resume(arg.take()) { - ImapSortResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSortResult::Ok { ids, .. } => break ids, - ImapSortResult::Err { err, .. } => bail!(err), + ImapMailboxSortResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + ImapMailboxSortResult::Ok { ids, .. } => break ids, + ImapMailboxSortResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/envelope/thread.rs b/src/imap/envelope/thread.rs index 31cd7b5c..347ec964 100644 --- a/src/imap/envelope/thread.rs +++ b/src/imap/envelope/thread.rs @@ -3,14 +3,15 @@ use std::{collections::HashMap, fmt, num::NonZeroU32}; use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{fetch::*, select::*, thread::*}, + rfc3501::{fetch::*, select::*}, + rfc5256::thread::*, types::{ extensions::thread::{Thread, ThreadingAlgorithm}, fetch::{MacroOrMessageDataItemNames, MessageDataItem, MessageDataItemName}, sequence::SequenceSet, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::{stream::imap::ImapSession, terminal::printer::Printer}; use serde::{ser::SerializeStruct, Serialize, Serializer}; @@ -29,7 +30,7 @@ use crate::imap::{ /// - references (default) - uses References and In-Reply-To headers /// - orderedsubject - groups by normalized subject #[derive(Debug, Parser)] -pub struct ThreadEnvelopesCommand { +pub struct ImapEnvelopeThreadCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -48,20 +49,22 @@ pub struct ThreadEnvelopesCommand { pub seq: bool, } -impl ThreadEnvelopesCommand { +impl ImapEnvelopeThreadCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -70,18 +73,21 @@ impl ThreadEnvelopesCommand { let search_criteria = parse_query(&self.query)?; let mut arg = None; - let mut coroutine = ImapThread::new(imap.context, algorithm, search_criteria, !self.seq); + let mut coroutine = + ImapMessageThread::new(imap.context, algorithm, search_criteria, !self.seq); let threads = loop { match coroutine.resume(arg.take()) { - ImapThreadResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapThreadResult::Ok { + ImapMessageThreadResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageThreadResult::Ok { context, threads, .. } => { imap.context = context; break threads; } - ImapThreadResult::Err { err, .. } => bail!(err), + ImapMessageThreadResult::Err { err, .. } => bail!(err), } }; @@ -160,13 +166,13 @@ fn fetch_subjects( ]); let mut arg = None; - let mut coroutine = ImapFetch::new(imap.context, sequence_set, item_names, uid); + let mut coroutine = ImapMessageFetch::new(imap.context, sequence_set, item_names, uid); let data = loop { match coroutine.resume(arg.take()) { - ImapFetchResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchResult::Ok { data, .. } => break data, - ImapFetchResult::Err { err, .. } => bail!(err), + ImapMessageFetchResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + ImapMessageFetchResult::Ok { data, .. } => break data, + ImapMessageFetchResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/flag/add.rs b/src/imap/flag/add.rs index 8b18e594..5b13c936 100644 --- a/src/imap/flag/add.rs +++ b/src/imap/flag/add.rs @@ -1,13 +1,13 @@ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{select::*, store::*}, + rfc3501::{select::*, store::*}, types::{ flag::{Flag, StoreType}, IntoStatic, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -20,7 +20,7 @@ use crate::imap::{ /// This command adds the given flags to messages identified by the /// given sequence set. #[derive(Debug, Parser)] -pub struct AddFlagsCommand { +pub struct ImapFlagAddCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -38,20 +38,22 @@ pub struct AddFlagsCommand { pub seq: bool, } -impl AddFlagsCommand { +impl ImapFlagAddCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -64,14 +66,21 @@ impl AddFlagsCommand { .collect::>()?; let mut arg = None; - let mut coroutine = - ImapStoreSilent::new(imap.context, sequence_set, StoreType::Add, flags, !self.seq); + let mut coroutine = ImapMessageStoreSilent::new( + imap.context, + sequence_set, + StoreType::Add, + flags, + !self.seq, + ); loop { match coroutine.resume(arg.take()) { - ImapStoreSilentResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStoreSilentResult::Ok { .. } => break, - ImapStoreSilentResult::Err { err, .. } => bail!(err), + ImapMessageStoreSilentResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageStoreSilentResult::Ok { .. } => break, + ImapMessageStoreSilentResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/flag/command.rs b/src/imap/flag/command.rs index abe4757d..571680af 100644 --- a/src/imap/flag/command.rs +++ b/src/imap/flag/command.rs @@ -5,8 +5,8 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::imap::{ account::ImapAccount, flag::{ - add::AddFlagsCommand, list::ListFlagsCommand, remove::RemoveFlagsCommand, - set::SetFlagsCommand, + add::ImapFlagAddCommand, list::ImapFlagListCommand, remove::ImapFlagRemoveCommand, + set::ImapFlagSetCommand, }, }; @@ -15,14 +15,14 @@ use crate::imap::{ /// A flag is a label attached to a message. This subcommand allows /// you to manage them. #[derive(Debug, Subcommand)] -pub enum FlagCommand { - List(ListFlagsCommand), - Add(AddFlagsCommand), - Set(SetFlagsCommand), - Remove(RemoveFlagsCommand), +pub enum ImapFlagCommand { + List(ImapFlagListCommand), + Add(ImapFlagAddCommand), + Set(ImapFlagSetCommand), + Remove(ImapFlagRemoveCommand), } -impl FlagCommand { +impl ImapFlagCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { match self { Self::List(cmd) => cmd.execute(printer, account), diff --git a/src/imap/flag/list.rs b/src/imap/flag/list.rs index fd135a79..b09a8fbe 100644 --- a/src/imap/flag/list.rs +++ b/src/imap/flag/list.rs @@ -4,10 +4,10 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, ContentArrangement, Row, Table}; use io_imap::{ - coroutines::select::*, + rfc3501::select::*, types::flag::{Flag, FlagPerm}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::{Serialize, Serializer}; @@ -19,29 +19,31 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// available in the given mailbox. These flags come from the SELECT /// response. #[derive(Debug, Parser)] -pub struct ListFlagsCommand { +pub struct ImapFlagListCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl ListFlagsCommand { +impl ImapFlagListCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); let (flags, permanent_flags) = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { data, .. } => { + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { data, .. } => { break ( data.flags.unwrap_or_default(), data.permanent_flags.unwrap_or_default(), ) } - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/flag/remove.rs b/src/imap/flag/remove.rs index da13cd7f..ea6a35bb 100644 --- a/src/imap/flag/remove.rs +++ b/src/imap/flag/remove.rs @@ -1,13 +1,13 @@ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{select::*, store::*}, + rfc3501::{select::*, store::*}, types::{ flag::{Flag, StoreType}, IntoStatic, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -20,7 +20,7 @@ use crate::imap::{ /// This command removes the specified flag(s) from message(s) /// identified by the given sequence set. #[derive(Debug, Parser)] -pub struct RemoveFlagsCommand { +pub struct ImapFlagRemoveCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -38,20 +38,22 @@ pub struct RemoveFlagsCommand { pub seq: bool, } -impl RemoveFlagsCommand { +impl ImapFlagRemoveCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -64,7 +66,7 @@ impl RemoveFlagsCommand { .collect::>()?; let mut arg = None; - let mut coroutine = ImapStoreSilent::new( + let mut coroutine = ImapMessageStoreSilent::new( imap.context, sequence_set, StoreType::Remove, @@ -74,9 +76,11 @@ impl RemoveFlagsCommand { loop { match coroutine.resume(arg.take()) { - ImapStoreSilentResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStoreSilentResult::Ok { .. } => break, - ImapStoreSilentResult::Err { err, .. } => bail!(err), + ImapMessageStoreSilentResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageStoreSilentResult::Ok { .. } => break, + ImapMessageStoreSilentResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/flag/set.rs b/src/imap/flag/set.rs index 28ea6afd..9ba7a574 100644 --- a/src/imap/flag/set.rs +++ b/src/imap/flag/set.rs @@ -1,13 +1,13 @@ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{select::*, store::*}, + rfc3501::{select::*, store::*}, types::{ flag::{Flag, StoreType}, IntoStatic, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -20,7 +20,7 @@ use crate::imap::{ /// This command replaces all existing flags on messages identified by /// the given sequence set with the specified flags. #[derive(Debug, Parser)] -pub struct SetFlagsCommand { +pub struct ImapFlagSetCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -38,20 +38,22 @@ pub struct SetFlagsCommand { pub seq: bool, } -impl SetFlagsCommand { +impl ImapFlagSetCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -64,7 +66,7 @@ impl SetFlagsCommand { .collect::>()?; let mut arg = None; - let mut coroutine = ImapStoreSilent::new( + let mut coroutine = ImapMessageStoreSilent::new( imap.context, sequence_set, StoreType::Replace, @@ -74,9 +76,11 @@ impl SetFlagsCommand { loop { match coroutine.resume(arg.take()) { - ImapStoreSilentResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStoreSilentResult::Ok { .. } => break, - ImapStoreSilentResult::Err { err, .. } => bail!(err), + ImapMessageStoreSilentResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageStoreSilentResult::Ok { .. } => break, + ImapMessageStoreSilentResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/id.rs b/src/imap/id.rs index df2f706a..fcfc4e65 100644 --- a/src/imap/id.rs +++ b/src/imap/id.rs @@ -4,13 +4,13 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, Row, Table}; use io_imap::{ - coroutines::id::*, + rfc2971::id::*, types::{ core::{IString, NString}, IntoStatic, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -24,13 +24,13 @@ use crate::imap::account::ImapAccount; /// /// [RFC 2971]: https://www.rfc-editor.org/rfc/rfc2971.html #[derive(Debug, Parser)] -pub struct IdCommand { +pub struct ImapIdCommand { #[arg(short, long, num_args = 1..)] #[arg(value_name = "KEY:VAL", value_parser = parameter_parser)] parameter: Option, NString<'static>)>>, } -impl IdCommand { +impl ImapIdCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mut params = HashMap::new(); @@ -59,13 +59,13 @@ impl IdCommand { } let mut arg = None; - let mut coroutine = ImapId::new(imap.context, Some(params.into_iter().collect())); + let mut coroutine = ImapServerId::new(imap.context, Some(params.into_iter().collect())); let params = loop { match coroutine.resume(arg.take()) { - ImapIdResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapIdResult::Ok { server_id, .. } => break server_id, - ImapIdResult::Err { err, .. } => bail!(err), + ImapServerIdResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + ImapServerIdResult::Ok { server_id, .. } => break server_id, + ImapServerIdResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/mailbox/close.rs b/src/imap/mailbox/close.rs index 8103c1c9..7c133e94 100644 --- a/src/imap/mailbox/close.rs +++ b/src/imap/mailbox/close.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::close::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::close::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::account::ImapAccount; @@ -16,20 +16,22 @@ use crate::imap::account::ImapAccount; /// /// https://github.com/pimalaya/sirup #[derive(Debug, Parser)] -pub struct CloseMailboxCommand; +pub struct ImapMailboxCloseCommand; -impl CloseMailboxCommand { +impl ImapMailboxCloseCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mut arg = None; - let mut close_coroutine = ImapClose::new(imap.context); + let mut close_coroutine = ImapMailboxClose::new(imap.context); loop { match close_coroutine.resume(arg.take()) { - ImapCloseResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapCloseResult::Ok { .. } => break, - ImapCloseResult::Err { err, .. } => bail!(err), + ImapMailboxCloseResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxCloseResult::Ok { .. } => break, + ImapMailboxCloseResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/command.rs b/src/imap/mailbox/command.rs index 2c54a5a4..3498caae 100644 --- a/src/imap/mailbox/command.rs +++ b/src/imap/mailbox/command.rs @@ -5,11 +5,12 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::imap::{ account::ImapAccount, mailbox::{ - close::CloseMailboxCommand, create::CreateMailboxCommand, delete::DeleteMailboxCommand, - expunge::ExpungeMailboxCommand, list::ListMailboxesCommand, purge::PurgeMailboxCommand, - rename::RenameMailboxCommand, select::SelectMailboxCommand, status::StatusMailboxCommand, - subscribe::SubscribeMailboxCommand, unselect::UnselectMailboxCommand, - unsubscribe::UnsubscribeMailboxCommand, + close::ImapMailboxCloseCommand, create::ImapMailboxCreateCommand, + delete::ImapMailboxDeleteCommand, expunge::ImapMailboxExpungeCommand, + list::ImapMailboxListCommand, purge::ImapMailboxPurgeCommand, + rename::ImapMailboxRenameCommand, select::ImapMailboxSelectCommand, + status::ImapMailboxStatusCommand, subscribe::ImapMailboxSubscribeCommand, + unselect::ImapMailboxUnselectCommand, unsubscribe::ImapMailboxUnsubscribeCommand, }, }; @@ -18,25 +19,25 @@ use crate::imap::{ /// A mailbox is a message container. This subcommand allows you to /// manage them. #[derive(Debug, Subcommand)] -pub enum MailboxCommand { - Close(CloseMailboxCommand), +pub enum ImapMailboxCommand { + Close(ImapMailboxCloseCommand), #[command(alias = "add", alias = "new")] - Create(CreateMailboxCommand), + Create(ImapMailboxCreateCommand), #[command(alias = "remove", alias = "rm")] - Delete(DeleteMailboxCommand), - Expunge(ExpungeMailboxCommand), + Delete(ImapMailboxDeleteCommand), + Expunge(ImapMailboxExpungeCommand), #[command(alias = "lst")] - List(ListMailboxesCommand), - Purge(PurgeMailboxCommand), - Rename(RenameMailboxCommand), - Select(SelectMailboxCommand), - Status(StatusMailboxCommand), - Subscribe(SubscribeMailboxCommand), - Unselect(UnselectMailboxCommand), - Unsubscribe(UnsubscribeMailboxCommand), + List(ImapMailboxListCommand), + Purge(ImapMailboxPurgeCommand), + Rename(ImapMailboxRenameCommand), + Select(ImapMailboxSelectCommand), + Status(ImapMailboxStatusCommand), + Subscribe(ImapMailboxSubscribeCommand), + Unselect(ImapMailboxUnselectCommand), + Unsubscribe(ImapMailboxUnsubscribeCommand), } -impl MailboxCommand { +impl ImapMailboxCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { match self { Self::Close(cmd) => cmd.execute(printer, account), diff --git a/src/imap/mailbox/create.rs b/src/imap/mailbox/create.rs index b0b8fbc4..32d4519e 100644 --- a/src/imap/mailbox/create.rs +++ b/src/imap/mailbox/create.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::create::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::create::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -11,25 +11,27 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// This command allows you to create a new mailbox using the given /// name. #[derive(Debug, Parser)] -pub struct CreateMailboxCommand { +pub struct ImapMailboxCreateCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl CreateMailboxCommand { +impl ImapMailboxCreateCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapCreate::new(imap.context, mailbox); + let mut coroutine = ImapMailboxCreate::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapCreateResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapCreateResult::Ok { .. } => break, - ImapCreateResult::Err { err, .. } => bail!(err), + ImapMailboxCreateResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxCreateResult::Ok { .. } => break, + ImapMailboxCreateResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/delete.rs b/src/imap/mailbox/delete.rs index bff14cf8..04f7df33 100644 --- a/src/imap/mailbox/delete.rs +++ b/src/imap/mailbox/delete.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::delete::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::delete::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -11,24 +11,26 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// All emails from the given mailbox are definitely deleted. The /// mailbox is also deleted after execution of the command. #[derive(Debug, Parser)] -pub struct DeleteMailboxCommand { +pub struct ImapMailboxDeleteCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl DeleteMailboxCommand { +impl ImapMailboxDeleteCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapDelete::new(imap.context, mailbox); + let mut coroutine = ImapMailboxDelete::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapDeleteResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapDeleteResult::Ok { .. } => break, - ImapDeleteResult::Err { err, .. } => bail!(err), + ImapMailboxDeleteResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxDeleteResult::Ok { .. } => break, + ImapMailboxDeleteResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/expunge.rs b/src/imap/mailbox/expunge.rs index ebb30a49..7314220c 100644 --- a/src/imap/mailbox/expunge.rs +++ b/src/imap/mailbox/expunge.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::{expunge::*, select::*}; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::{expunge::*, select::*}; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -14,39 +14,43 @@ use crate::imap::{ /// All envelopes with the \Deleted flag will be definitely removed /// from the given mailbox. #[derive(Debug, Parser)] -pub struct ExpungeMailboxCommand { +pub struct ImapMailboxExpungeCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, #[command(flatten)] pub mailbox_no_select: MailboxNoSelectFlag, } -impl ExpungeMailboxCommand { +impl ImapMailboxExpungeCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } let mut arg = None; - let mut coroutine = ImapExpunge::new(imap.context); + let mut coroutine = ImapMailboxExpunge::new(imap.context); loop { match coroutine.resume(arg.take()) { - ImapExpungeResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapExpungeResult::Ok { .. } => break, - ImapExpungeResult::Err { err, .. } => bail!(err), + ImapMailboxExpungeResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxExpungeResult::Ok { .. } => break, + ImapMailboxExpungeResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/list.rs b/src/imap/mailbox/list.rs index 619e687f..00973475 100644 --- a/src/imap/mailbox/list.rs +++ b/src/imap/mailbox/list.rs @@ -4,10 +4,10 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, Row, Table}; use io_imap::{ - coroutines::{list::*, lsub::*}, + rfc3501::{list::*, lsub::*}, types::{core::QuotedChar, flag::FlagNameAttribute, mailbox::Mailbox}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -19,7 +19,7 @@ use crate::imap::account::ImapAccount; /// By default, only subscribed mailboxes are listed. Use --all to /// list all mailboxes. #[derive(Debug, Parser)] -pub struct ListMailboxesCommand { +pub struct ImapMailboxListCommand { /// List all mailboxes, not just subscribed ones. #[arg(short = 'A', long)] pub all: bool, @@ -33,7 +33,7 @@ pub struct ListMailboxesCommand { pub pattern: String, } -impl ListMailboxesCommand { +impl ImapMailboxListCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let reference = self.reference.try_into()?; @@ -41,24 +41,28 @@ impl ListMailboxesCommand { let mailboxes = if self.all { let mut arg = None; - let mut coroutine = ImapList::new(imap.context, reference, pattern); + let mut coroutine = ImapMailboxList::new(imap.context, reference, pattern); loop { match coroutine.resume(arg.take()) { - ImapListResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapListResult::Ok { mailboxes, .. } => break mailboxes, - ImapListResult::Err { err, .. } => bail!(err), + ImapMailboxListResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxListResult::Ok { mailboxes, .. } => break mailboxes, + ImapMailboxListResult::Err { err, .. } => bail!(err), } } } else { let mut arg = None; - let mut coroutine = ImapLsub::new(imap.context, reference, pattern); + let mut coroutine = ImapMailboxLsub::new(imap.context, reference, pattern); loop { match coroutine.resume(arg.take()) { - ImapLsubResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapLsubResult::Ok { mailboxes, .. } => break mailboxes, - ImapLsubResult::Err { err, .. } => bail!(err), + ImapMailboxLsubResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxLsubResult::Ok { mailboxes, .. } => break mailboxes, + ImapMailboxLsubResult::Err { err, .. } => bail!(err), } } }; diff --git a/src/imap/mailbox/purge.rs b/src/imap/mailbox/purge.rs index 871ea7f2..d12a0230 100644 --- a/src/imap/mailbox/purge.rs +++ b/src/imap/mailbox/purge.rs @@ -1,10 +1,10 @@ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{expunge::*, select::*, store::*}, + rfc3501::{expunge::*, select::*, store::*}, types::flag::{Flag, StoreType}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -18,33 +18,35 @@ use crate::imap::{ /// All emails from the given mailbox are definitely deleted. The /// purged mailbox will remain empty after execution of the command. #[derive(Debug, Parser)] -pub struct PurgeMailboxCommand { +pub struct ImapMailboxPurgeCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, #[command(flatten)] pub mailbox_no_select: MailboxNoSelectFlag, } -impl PurgeMailboxCommand { +impl ImapMailboxPurgeCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } let mut arg = None; - let mut coroutine = ImapStoreSilent::new( + let mut coroutine = ImapMessageStoreSilent::new( imap.context, "1:*".try_into()?, StoreType::Add, @@ -54,20 +56,24 @@ impl PurgeMailboxCommand { imap.context = loop { match coroutine.resume(arg.take()) { - ImapStoreSilentResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStoreSilentResult::Ok { context, .. } => break context, - ImapStoreSilentResult::Err { err, .. } => bail!(err), + ImapMessageStoreSilentResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageStoreSilentResult::Ok { context, .. } => break context, + ImapMessageStoreSilentResult::Err { err, .. } => bail!(err), } }; let mut arg = None; - let mut coroutine = ImapExpunge::new(imap.context); + let mut coroutine = ImapMailboxExpunge::new(imap.context); loop { match coroutine.resume(arg.take()) { - ImapExpungeResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapExpungeResult::Ok { .. } => break, - ImapExpungeResult::Err { err, .. } => bail!(err), + ImapMailboxExpungeResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxExpungeResult::Ok { .. } => break, + ImapMailboxExpungeResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/rename.rs b/src/imap/mailbox/rename.rs index e889afff..c2457303 100644 --- a/src/imap/mailbox/rename.rs +++ b/src/imap/mailbox/rename.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::rename::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::rename::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -13,27 +13,29 @@ use crate::imap::{ /// /// This command renames an existing mailbox to a new name. #[derive(Debug, Parser)] -pub struct RenameMailboxCommand { +pub struct ImapMailboxRenameCommand { #[command(flatten)] pub mailbox_source_name: MailboxNameArg, #[command(flatten)] pub mailbox_dest_name: TargetMailboxNameArg, } -impl RenameMailboxCommand { +impl ImapMailboxRenameCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let from = self.mailbox_source_name.inner.try_into()?; let to = self.mailbox_dest_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapRename::new(imap.context, from, to); + let mut coroutine = ImapMailboxRename::new(imap.context, from, to); loop { match coroutine.resume(arg.take()) { - ImapRenameResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapRenameResult::Ok { .. } => break, - ImapRenameResult::Err { err, .. } => bail!(err), + ImapMailboxRenameResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxRenameResult::Ok { .. } => break, + ImapMailboxRenameResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/select.rs b/src/imap/mailbox/select.rs index 2733a162..0de01e80 100644 --- a/src/imap/mailbox/select.rs +++ b/src/imap/mailbox/select.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::select::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::select::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -15,24 +15,26 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// /// https://github.com/pimalaya/sirup #[derive(Debug, Parser)] -pub struct SelectMailboxCommand { +pub struct ImapMailboxSelectCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl SelectMailboxCommand { +impl ImapMailboxSelectCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { .. } => break, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { .. } => break, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/status.rs b/src/imap/mailbox/status.rs index 46b3f1ac..42b453b6 100644 --- a/src/imap/mailbox/status.rs +++ b/src/imap/mailbox/status.rs @@ -4,10 +4,10 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{Cell, Row, Table}; use io_imap::{ - coroutines::status::*, + rfc3501::status::*, types::status::{StatusDataItem, StatusDataItemName}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::{Serialize, Serializer}; @@ -18,12 +18,12 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// This command displays status information about a mailbox, /// including message counts and UID values. #[derive(Debug, Parser)] -pub struct StatusMailboxCommand { +pub struct ImapMailboxStatusCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl StatusMailboxCommand { +impl ImapMailboxStatusCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; @@ -36,13 +36,15 @@ impl StatusMailboxCommand { ]; let mut arg = None; - let mut coroutine = ImapStatus::new(imap.context, mailbox, item_names); + let mut coroutine = ImapMailboxStatus::new(imap.context, mailbox, item_names); let items = loop { match coroutine.resume(arg.take()) { - ImapStatusResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapStatusResult::Ok { items, .. } => break items, - ImapStatusResult::Err { err, .. } => bail!(err), + ImapMailboxStatusResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxStatusResult::Ok { items, .. } => break items, + ImapMailboxStatusResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/mailbox/subscribe.rs b/src/imap/mailbox/subscribe.rs index 210c66a0..b3362395 100644 --- a/src/imap/mailbox/subscribe.rs +++ b/src/imap/mailbox/subscribe.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::subscribe::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::subscribe::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -11,24 +11,26 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// This command subscribes to a mailbox, making it appear in the /// list of subscribed mailboxes. #[derive(Debug, Parser)] -pub struct SubscribeMailboxCommand { +pub struct ImapMailboxSubscribeCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl SubscribeMailboxCommand { +impl ImapMailboxSubscribeCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapSubscribe::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSubscribe::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapSubscribeResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSubscribeResult::Ok { .. } => break, - ImapSubscribeResult::Err { err, .. } => bail!(err), + ImapMailboxSubscribeResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSubscribeResult::Ok { .. } => break, + ImapMailboxSubscribeResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/unselect.rs b/src/imap/mailbox/unselect.rs index 0c532281..7d887fa1 100644 --- a/src/imap/mailbox/unselect.rs +++ b/src/imap/mailbox/unselect.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::unselect::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3691::unselect::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::account::ImapAccount; @@ -15,19 +15,21 @@ use crate::imap::account::ImapAccount; /// /// https://github.com/pimalaya/sirup #[derive(Debug, Parser)] -pub struct UnselectMailboxCommand; +pub struct ImapMailboxUnselectCommand; -impl UnselectMailboxCommand { +impl ImapMailboxUnselectCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mut arg = None; - let mut unselect_coroutine = ImapUnselect::new(imap.context); + let mut coroutine = ImapMailboxUnselect::new(imap.context); loop { - match unselect_coroutine.resume(arg.take()) { - ImapUnselectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapUnselectResult::Ok { .. } => break, - ImapUnselectResult::Err { err, .. } => bail!(err), + match coroutine.resume(arg.take()) { + ImapMailboxUnselectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxUnselectResult::Ok { .. } => break, + ImapMailboxUnselectResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/mailbox/unsubscribe.rs b/src/imap/mailbox/unsubscribe.rs index f62f3206..120e13a0 100644 --- a/src/imap/mailbox/unsubscribe.rs +++ b/src/imap/mailbox/unsubscribe.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::coroutines::unsubscribe::*; -use io_stream::runtimes::std::handle; +use io_imap::rfc3501::unsubscribe::*; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -11,24 +11,26 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// This command unsubscribes from a mailbox, removing it from the /// list of subscribed mailboxes. #[derive(Debug, Parser)] -pub struct UnsubscribeMailboxCommand { +pub struct ImapMailboxUnsubscribeCommand { #[command(flatten)] pub mailbox_name: MailboxNameArg, } -impl UnsubscribeMailboxCommand { +impl ImapMailboxUnsubscribeCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapUnsubscribe::new(imap.context, mailbox); + let mut coroutine = ImapMailboxUnsubscribe::new(imap.context, mailbox); loop { match coroutine.resume(arg.take()) { - ImapUnsubscribeResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapUnsubscribeResult::Ok { .. } => break, - ImapUnsubscribeResult::Err { err, .. } => bail!(err), + ImapMailboxUnsubscribeResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxUnsubscribeResult::Ok { .. } => break, + ImapMailboxUnsubscribeResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/message/command.rs b/src/imap/message/command.rs index 53a8ff9f..78103bf5 100644 --- a/src/imap/message/command.rs +++ b/src/imap/message/command.rs @@ -5,8 +5,8 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::imap::{ account::ImapAccount, message::{ - copy::CopyMessageCommand, export::ExportMessageCommand, get::GetMessageCommand, - r#move::MoveMessagesCommand, read::ReadMessageCommand, save::SaveMessageCommand, + copy::ImapMessageCopyCommand, export::ImapMessageExportCommand, get::ImapMessageGetCommand, + r#move::ImapMessageMoveCommand, read::ImapMessageReadCommand, save::ImapMessageSaveCommand, }, }; @@ -16,16 +16,16 @@ use crate::imap::{ /// subcommand allows you to save, get, read, export, copy, and move /// messages. #[derive(Debug, Subcommand)] -pub enum MessageCommand { - Save(SaveMessageCommand), - Get(GetMessageCommand), - Read(ReadMessageCommand), - Export(ExportMessageCommand), - Copy(CopyMessageCommand), - Move(MoveMessagesCommand), +pub enum ImapMessageCommand { + Save(ImapMessageSaveCommand), + Get(ImapMessageGetCommand), + Read(ImapMessageReadCommand), + Export(ImapMessageExportCommand), + Copy(ImapMessageCopyCommand), + Move(ImapMessageMoveCommand), } -impl MessageCommand { +impl ImapMessageCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { match self { Self::Save(cmd) => cmd.execute(printer, account), diff --git a/src/imap/message/copy.rs b/src/imap/message/copy.rs index 2bb9ea1e..c8e52631 100644 --- a/src/imap/message/copy.rs +++ b/src/imap/message/copy.rs @@ -1,10 +1,10 @@ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{copy::*, select::*}, + rfc3501::{copy::*, select::*}, types::mailbox::Mailbox, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -17,7 +17,7 @@ use crate::imap::{ /// This command copies message(s) identified by the given sequence /// set from the source mailbox to the destination mailbox. #[derive(Debug, Parser)] -pub struct CopyMessageCommand { +pub struct ImapMessageCopyCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -34,20 +34,22 @@ pub struct CopyMessageCommand { pub seq: bool, } -impl CopyMessageCommand { +impl ImapMessageCopyCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -56,13 +58,14 @@ impl CopyMessageCommand { let destination: Mailbox = self.mailbox_dest_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapCopy::new(imap.context, sequence_set, destination, !self.seq); + let mut coroutine = + ImapMessageCopy::new(imap.context, sequence_set, destination, !self.seq); loop { match coroutine.resume(arg.take()) { - ImapCopyResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapCopyResult::Ok { .. } => break, - ImapCopyResult::Err { err, .. } => bail!(err), + ImapMessageCopyResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + ImapMessageCopyResult::Ok { .. } => break, + ImapMessageCopyResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/message/export.rs b/src/imap/message/export.rs index 54c14e36..70b7c014 100644 --- a/src/imap/message/export.rs +++ b/src/imap/message/export.rs @@ -8,10 +8,10 @@ use std::{ use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{fetch::*, select::*}, + rfc3501::{fetch::*, select::*}, types::fetch::{MacroOrMessageDataItemNames, MessageDataItem, MessageDataItemName}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use mail_parser::{MessageParser, MimeHeaders}; use pimalaya_toolbox::terminal::printer::{Message, Printer}; @@ -35,7 +35,7 @@ pub enum ExportType { /// - eml: Save as .eml file /// - parts: Export all MIME parts to separate files #[derive(Debug, Parser)] -pub struct ExportMessageCommand { +pub struct ImapMessageExportCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, @@ -60,20 +60,22 @@ pub struct ExportMessageCommand { pub open: bool, } -impl ExportMessageCommand { +impl ImapMessageExportCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; // SELECT mailbox let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); let context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; @@ -90,13 +92,15 @@ impl ExportMessageCommand { }]); let mut arg = None; - let mut coroutine = ImapFetchFirst::new(context, id, item_names, !self.seq); + let mut coroutine = ImapMessageFetchFirst::new(context, id, item_names, !self.seq); let items = loop { match coroutine.resume(arg.take()) { - ImapFetchFirstResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchFirstResult::Ok { items, .. } => break items, - ImapFetchFirstResult::Err { err, .. } => bail!(err), + ImapMessageFetchFirstResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageFetchFirstResult::Ok { items, .. } => break items, + ImapMessageFetchFirstResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/message/get.rs b/src/imap/message/get.rs index 0b08e0cb..e5b641cf 100644 --- a/src/imap/message/get.rs +++ b/src/imap/message/get.rs @@ -4,10 +4,10 @@ use anyhow::{bail, Result}; use clap::Parser; use comfy_table::{presets, Cell, ContentArrangement, Row, Table}; use io_imap::{ - coroutines::{fetch::*, select::*}, + rfc3501::{fetch::*, select::*}, types::fetch::{MacroOrMessageDataItemNames, MessageDataItem, MessageDataItemName}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use mail_parser::{Addr, Address, ContentType, Message, MessageParser, MimeHeaders}; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -22,7 +22,7 @@ use crate::imap::{ /// This command fetches a message and displays its headers along with /// the body structure tree showing all MIME parts. #[derive(Debug, Parser)] -pub struct GetMessageCommand { +pub struct ImapMessageGetCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -35,7 +35,7 @@ pub struct GetMessageCommand { pub seq: bool, } -impl GetMessageCommand { +impl ImapMessageGetCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; @@ -45,13 +45,15 @@ impl GetMessageCommand { if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -64,13 +66,15 @@ impl GetMessageCommand { }]); let mut arg = None; - let mut coroutine = ImapFetchFirst::new(imap.context, id, item_names, !self.seq); + let mut coroutine = ImapMessageFetchFirst::new(imap.context, id, item_names, !self.seq); let items = loop { match coroutine.resume(arg.take()) { - ImapFetchFirstResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchFirstResult::Ok { items, .. } => break items, - ImapFetchFirstResult::Err { err, .. } => bail!(err), + ImapMessageFetchFirstResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageFetchFirstResult::Ok { items, .. } => break items, + ImapMessageFetchFirstResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/message/move.rs b/src/imap/message/move.rs index a098caba..3afbe97b 100644 --- a/src/imap/message/move.rs +++ b/src/imap/message/move.rs @@ -1,10 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; -use io_imap::{ - coroutines::{r#move::*, select::*}, - types::mailbox::Mailbox, -}; -use io_stream::runtimes::std::handle; +use io_imap::{rfc3501::select::*, rfc6851::r#move::*, types::mailbox::Mailbox}; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{ @@ -18,7 +15,7 @@ use crate::imap::{ /// from the source mailbox to the destination mailbox. Requires the /// MOVE IMAP extension. #[derive(Debug, Parser)] -pub struct MoveMessagesCommand { +pub struct ImapMessageMoveCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -35,20 +32,22 @@ pub struct MoveMessagesCommand { pub seq: bool, } -impl MoveMessagesCommand { +impl ImapMessageMoveCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -57,13 +56,14 @@ impl MoveMessagesCommand { let destination: Mailbox<'static> = self.mailbox_dest_name.inner.try_into()?; let mut arg = None; - let mut coroutine = ImapMove::new(imap.context, sequence_set, destination, !self.seq); + let mut coroutine = + ImapMessageMove::new(imap.context, sequence_set, destination, !self.seq); loop { match coroutine.resume(arg.take()) { - ImapMoveResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapMoveResult::Ok { .. } => break, - ImapMoveResult::Err { err, .. } => bail!(err), + ImapMessageMoveResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + ImapMessageMoveResult::Ok { .. } => break, + ImapMessageMoveResult::Err { err, .. } => bail!(err), } } diff --git a/src/imap/message/read.rs b/src/imap/message/read.rs index 9dc26d8a..ebaefd80 100644 --- a/src/imap/message/read.rs +++ b/src/imap/message/read.rs @@ -3,10 +3,10 @@ use std::{fmt, num::NonZeroU32}; use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::{fetch::*, select::*}, + rfc3501::{fetch::*, select::*}, types::fetch::{MacroOrMessageDataItemNames, MessageDataItem, MessageDataItemName}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use mail_parser::{Message, MessageParser}; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -21,7 +21,7 @@ use crate::imap::{ /// This command fetches a message and displays its text content. /// By default it shows plain text content; use --html to show HTML. #[derive(Debug, Parser)] -pub struct ReadMessageCommand { +pub struct ImapMessageReadCommand { #[command(flatten)] pub mailbox_name: MailboxNameOptionalFlag, #[command(flatten)] @@ -40,20 +40,22 @@ pub struct ReadMessageCommand { pub html: bool, } -impl ReadMessageCommand { +impl ImapMessageReadCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox = self.mailbox_name.inner.try_into()?; if !self.mailbox_no_select.inner { let mut arg = None; - let mut coroutine = ImapSelect::new(imap.context, mailbox); + let mut coroutine = ImapMailboxSelect::new(imap.context, mailbox); imap.context = loop { match coroutine.resume(arg.take()) { - ImapSelectResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapSelectResult::Ok { context, .. } => break context, - ImapSelectResult::Err { err, .. } => bail!(err), + ImapMailboxSelectResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMailboxSelectResult::Ok { context, .. } => break context, + ImapMailboxSelectResult::Err { err, .. } => bail!(err), } }; } @@ -70,13 +72,15 @@ impl ReadMessageCommand { }]); let mut arg = None; - let mut coroutine = ImapFetchFirst::new(imap.context, id, item_names, !self.seq); + let mut coroutine = ImapMessageFetchFirst::new(imap.context, id, item_names, !self.seq); let items = loop { match coroutine.resume(arg.take()) { - ImapFetchFirstResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapFetchFirstResult::Ok { items, .. } => break items, - ImapFetchFirstResult::Err { err, .. } => bail!(err), + ImapMessageFetchFirstResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageFetchFirstResult::Ok { items, .. } => break items, + ImapMessageFetchFirstResult::Err { err, .. } => bail!(err), } }; diff --git a/src/imap/message/save.rs b/src/imap/message/save.rs index 8192562c..ad03ef6f 100644 --- a/src/imap/message/save.rs +++ b/src/imap/message/save.rs @@ -3,13 +3,13 @@ use std::io::{stdin, BufRead, IsTerminal}; use anyhow::{bail, Result}; use clap::Parser; use io_imap::{ - coroutines::append::*, + rfc3501::append::*, types::{ core::Literal, extensions::binary::LiteralOrLiteral8, flag::Flag, mailbox::Mailbox, IntoStatic, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; @@ -19,7 +19,7 @@ use crate::imap::{account::ImapAccount, mailbox::arg::MailboxNameArg}; /// This command appends a message to the specified mailbox. The /// message is read from stdin in RFC 5322 format (raw email). #[derive(Debug, Parser)] -pub struct SaveMessageCommand { +pub struct ImapMessageSaveCommand { #[command(flatten)] pub mailbox: MailboxNameArg, @@ -33,7 +33,7 @@ pub struct SaveMessageCommand { pub message: Vec, } -impl SaveMessageCommand { +impl ImapMessageSaveCommand { pub fn execute(self, printer: &mut impl Printer, account: ImapAccount) -> Result<()> { let mut imap = account.new_imap_session()?; let mailbox: Mailbox<'static> = self.mailbox.inner.try_into()?; @@ -61,13 +61,15 @@ impl SaveMessageCommand { .collect::>()?; let mut arg = None; - let mut coroutine = ImapAppend::new(imap.context, mailbox, flags, None, message); + let mut coroutine = ImapMessageAppend::new(imap.context, mailbox, flags, None, message); loop { match coroutine.resume(arg.take()) { - ImapAppendResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - ImapAppendResult::Ok { .. } => break, - ImapAppendResult::Err { err, .. } => bail!(err), + ImapMessageAppendResult::Io { input } => { + arg = Some(handle(&mut imap.stream, input)?) + } + ImapMessageAppendResult::Ok { .. } => break, + ImapMessageAppendResult::Err { err, .. } => bail!(err), } } diff --git a/src/jmap/command.rs b/src/jmap/command.rs index 5b016636..f3979fab 100644 --- a/src/jmap/command.rs +++ b/src/jmap/command.rs @@ -3,10 +3,10 @@ use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{ - account::JmapAccount, email::command::JmapEmailCommand, identity::command::IdentityCommand, - mailbox::command::JmapMailboxCommand, query::QueryCommand, - submission::command::SubmissionCommand, thread::command::ThreadCommand, - vacation::command::VacationCommand, + account::JmapAccount, email::command::JmapEmailCommand, identity::command::JmapIdentityCommand, + mailbox::command::JmapMailboxCommand, query::JmapQueryCommand, + submission::command::JmapSubmissionCommand, thread::command::JmapThreadCommand, + vacation::command::JmapVacationCommand, }; /// JMAP CLI (requires the `jmap` cargo feature). @@ -26,17 +26,17 @@ pub enum JmapCommand { Emails(JmapEmailCommand), #[command(subcommand)] - Threads(ThreadCommand), + Threads(JmapThreadCommand), #[command(subcommand)] #[command(aliases = ["identities"])] - Identity(IdentityCommand), + Identity(JmapIdentityCommand), #[command(subcommand)] #[command(aliases = ["submissions", "submit"])] - Submission(SubmissionCommand), + Submission(JmapSubmissionCommand), #[command(subcommand)] #[command(alias = "vacation-response")] - Vacation(VacationCommand), - Query(QueryCommand), + Vacation(JmapVacationCommand), + Query(JmapQueryCommand), } impl JmapCommand { diff --git a/src/jmap/email/command.rs b/src/jmap/email/command.rs index b23d36ce..40fc36a2 100644 --- a/src/jmap/email/command.rs +++ b/src/jmap/email/command.rs @@ -5,9 +5,10 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{ account::JmapAccount, email::{ - copy::JmapEmailCopyCommand, delete::JmapEmailDestroyCommand, export::ExportEmailCommand, - get::JmapEmailGetCommand, import::ImportEmailCommand, parse::ParseEmailCommand, - query::JmapEmailQueryCommand, read::ReadEmailCommand, update::JmapEmailUpdateCommand, + copy::JmapEmailCopyCommand, delete::JmapEmailDestroyCommand, + export::JmapEmailExportCommand, get::JmapEmailGetCommand, import::JmapEmailImportCommand, + parse::JmapEmailParseCommand, query::JmapEmailQueryCommand, read::JmapEmailReadCommand, + update::JmapEmailUpdateCommand, }, }; @@ -17,15 +18,15 @@ use crate::jmap::{ pub enum JmapEmailCommand { Get(JmapEmailGetCommand), Query(JmapEmailQueryCommand), - Read(ReadEmailCommand), + Read(JmapEmailReadCommand), #[command(alias = "edit")] Update(JmapEmailUpdateCommand), #[command(aliases = ["remove", "rm"])] Delete(JmapEmailDestroyCommand), Copy(JmapEmailCopyCommand), - Export(ExportEmailCommand), - Import(ImportEmailCommand), - Parse(ParseEmailCommand), + Export(JmapEmailExportCommand), + Import(JmapEmailImportCommand), + Parse(JmapEmailParseCommand), } impl JmapEmailCommand { diff --git a/src/jmap/email/copy.rs b/src/jmap/email/copy.rs index 98fed699..b33fc2ae 100644 --- a/src/jmap/email/copy.rs +++ b/src/jmap/email/copy.rs @@ -6,7 +6,7 @@ use io_jmap::{ rfc8621::coroutines::email_copy::{JmapEmailCopy, JmapEmailCopyResult}, rfc8621::types::email::EmailCopy, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/email/delete.rs b/src/jmap/email/delete.rs index ffc0e5ca..34d0b26d 100644 --- a/src/jmap/email/delete.rs +++ b/src/jmap/email/delete.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; use io_jmap::rfc8621::coroutines::email_set::{JmapEmailSet, JmapEmailSetArgs, JmapEmailSetResult}; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/email/export.rs b/src/jmap/email/export.rs index 5cf57317..6b0cb566 100644 --- a/src/jmap/email/export.rs +++ b/src/jmap/email/export.rs @@ -7,7 +7,7 @@ use io_jmap::{ }, rfc8621::coroutines::email_get::{JmapEmailGet, JmapEmailGetResult}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use url::Url; @@ -17,13 +17,13 @@ use crate::jmap::account::JmapAccount; /// /// Fetches the blobId via Email/get then downloads the raw message blob. #[derive(Debug, Parser)] -pub struct ExportEmailCommand { +pub struct JmapEmailExportCommand { /// The email ID to export. #[arg(value_name = "ID")] pub id: String, } -impl ExportEmailCommand { +impl JmapEmailExportCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let tls = account.backend.tls.clone().try_into()?; let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/email/get.rs b/src/jmap/email/get.rs index 64dd00b2..daeff919 100644 --- a/src/jmap/email/get.rs +++ b/src/jmap/email/get.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; use io_jmap::rfc8621::coroutines::email_get::{JmapEmailGet, JmapEmailGetResult}; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; diff --git a/src/jmap/email/import.rs b/src/jmap/email/import.rs index 0aeac044..9425da62 100644 --- a/src/jmap/email/import.rs +++ b/src/jmap/email/import.rs @@ -15,7 +15,7 @@ use io_jmap::{ types::email::EmailImport, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use url::Url; @@ -26,7 +26,7 @@ use crate::jmap::account::JmapAccount; /// Reads the raw message from stdin or as trailing arguments. Use /// `--upload-only` to stop after the upload and print the blobId. #[derive(Debug, Parser)] -pub struct ImportEmailCommand { +pub struct JmapEmailImportCommand { /// Mailbox ID(s) to place the imported email in. #[arg(long, value_name = "MAILBOX-ID")] pub mailbox_id: Vec, @@ -49,7 +49,7 @@ pub struct ImportEmailCommand { pub message: Vec, } -impl ImportEmailCommand { +impl JmapEmailImportCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let tls = account.backend.tls.clone().try_into()?; let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/email/parse.rs b/src/jmap/email/parse.rs index d8a3906b..e71970dd 100644 --- a/src/jmap/email/parse.rs +++ b/src/jmap/email/parse.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; use io_jmap::rfc8621::coroutines::email_parse::{JmapEmailParse, JmapEmailParseResult}; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -13,13 +13,13 @@ use crate::jmap::account::JmapAccount; /// Useful for reading attached .eml files or message blobs that are /// not yet stored as Email objects. #[derive(Debug, Parser)] -pub struct ParseEmailCommand { +pub struct JmapEmailParseCommand { /// Blob ID(s) to parse as RFC 5322 messages. #[arg(value_name = "ID", required = true)] pub blob_ids: Vec, } -impl ParseEmailCommand { +impl JmapEmailParseCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/email/query.rs b/src/jmap/email/query.rs index ecef6974..00790921 100644 --- a/src/jmap/email/query.rs +++ b/src/jmap/email/query.rs @@ -7,7 +7,7 @@ use io_jmap::{ rfc8621::coroutines::email_query::{JmapEmailQuery, JmapEmailQueryResult}, rfc8621::types::email::{Email, EmailAddress, EmailComparator, EmailFilter, EmailSortProperty}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; diff --git a/src/jmap/email/read.rs b/src/jmap/email/read.rs index dde62b9d..86388f76 100644 --- a/src/jmap/email/read.rs +++ b/src/jmap/email/read.rs @@ -4,7 +4,7 @@ use io_jmap::{ rfc8621::coroutines::email_get::{JmapEmailGet, JmapEmailGetResult}, rfc8621::types::email::EmailAddress, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::{Message, Printer}; @@ -14,7 +14,7 @@ use crate::jmap::account::JmapAccount; /// /// Shows headers and plain text body by default. #[derive(Debug, Parser)] -pub struct ReadEmailCommand { +pub struct JmapEmailReadCommand { /// The email ID(s) to read. #[arg(value_name = "ID", required = true)] pub ids: Vec, @@ -24,7 +24,7 @@ pub struct ReadEmailCommand { pub html: bool, } -impl ReadEmailCommand { +impl JmapEmailReadCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/email/update.rs b/src/jmap/email/update.rs index 065af0ee..7f4f584f 100644 --- a/src/jmap/email/update.rs +++ b/src/jmap/email/update.rs @@ -3,7 +3,7 @@ use std::collections::HashMap; use anyhow::{bail, Result}; use clap::Parser; use io_jmap::rfc8621::coroutines::email_set::{JmapEmailSet, JmapEmailSetArgs, JmapEmailSetResult}; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/identity/command.rs b/src/jmap/identity/command.rs index 625dd0fe..031ad94f 100644 --- a/src/jmap/identity/command.rs +++ b/src/jmap/identity/command.rs @@ -5,29 +5,29 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{ account::JmapAccount, identity::{ - create::JmapIdentityCreateCommand, delete::DeleteIdentityCommand, get::GetIdentityCommand, - update::UpdateIdentityCommand, + create::JmapIdentityCreateCommand, delete::JmapIdentityDeleteCommand, + get::JmapIdentityGetCommand, update::JmapIdentityUpdateCommand, }, }; /// Manage JMAP sender identities. #[derive(Debug, Subcommand)] -pub enum IdentityCommand { +pub enum JmapIdentityCommand { /// Fetch identities (Identity/get). #[command(aliases = ["lst", "list"])] - Get(GetIdentityCommand), + Get(JmapIdentityGetCommand), /// Create a new identity (Identity/set). #[command(aliases = ["add", "new"])] Create(JmapIdentityCreateCommand), /// Update an existing identity (Identity/set). #[command(alias = "edit")] - Update(UpdateIdentityCommand), + Update(JmapIdentityUpdateCommand), /// Delete an identity (Identity/set). #[command(aliases = ["remove", "rm"])] - Delete(DeleteIdentityCommand), + Delete(JmapIdentityDeleteCommand), } -impl IdentityCommand { +impl JmapIdentityCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/jmap/identity/create.rs b/src/jmap/identity/create.rs index 3df9ec5d..3891609d 100644 --- a/src/jmap/identity/create.rs +++ b/src/jmap/identity/create.rs @@ -6,7 +6,7 @@ use io_jmap::{ }, rfc8621::types::identity::IdentityCreate, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/identity/delete.rs b/src/jmap/identity/delete.rs index 55f8fb46..b22c0a19 100644 --- a/src/jmap/identity/delete.rs +++ b/src/jmap/identity/delete.rs @@ -3,20 +3,20 @@ use clap::Parser; use io_jmap::rfc8621::coroutines::identity_set::{ JmapIdentitySet, JmapIdentitySetArgs, JmapIdentitySetResult, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; /// Delete a JMAP sender identity (Identity/set). #[derive(Debug, Parser)] -pub struct DeleteIdentityCommand { +pub struct JmapIdentityDeleteCommand { /// Identity ID(s) to delete. #[arg(value_name = "ID", required = true)] pub ids: Vec, } -impl DeleteIdentityCommand { +impl JmapIdentityDeleteCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/identity/get.rs b/src/jmap/identity/get.rs index e1137cb0..8c876e6d 100644 --- a/src/jmap/identity/get.rs +++ b/src/jmap/identity/get.rs @@ -7,7 +7,7 @@ use io_jmap::{ rfc8621::coroutines::identity_get::{JmapIdentityGet, JmapIdentityGetResult}, rfc8621::types::identity::Identity, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -19,13 +19,13 @@ use crate::jmap::account::JmapAccount; /// Lists sender identities available for sending email. Pass no IDs to /// list all identities. #[derive(Debug, Parser)] -pub struct GetIdentityCommand { +pub struct JmapIdentityGetCommand { /// Identity ID(s) to retrieve (omit to get all). #[arg(value_name = "ID")] pub ids: Option>, } -impl GetIdentityCommand { +impl JmapIdentityGetCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/identity/update.rs b/src/jmap/identity/update.rs index d1bbc6cb..22fd874d 100644 --- a/src/jmap/identity/update.rs +++ b/src/jmap/identity/update.rs @@ -6,14 +6,14 @@ use io_jmap::{ }, rfc8621::types::identity::IdentityUpdate, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; /// Update a JMAP sender identity (Identity/set). #[derive(Debug, Parser)] -pub struct UpdateIdentityCommand { +pub struct JmapIdentityUpdateCommand { /// Identity ID to update. pub id: String, @@ -30,7 +30,7 @@ pub struct UpdateIdentityCommand { pub html_signature: Option, } -impl UpdateIdentityCommand { +impl JmapIdentityUpdateCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/mailbox/create.rs b/src/jmap/mailbox/create.rs index f0ca0e67..d3213496 100644 --- a/src/jmap/mailbox/create.rs +++ b/src/jmap/mailbox/create.rs @@ -6,7 +6,7 @@ use io_jmap::{ rfc8621::coroutines::mailbox_set::{JmapMailboxSet, JmapMailboxSetArgs, JmapMailboxSetResult}, rfc8621::types::mailbox::MailboxCreate, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/mailbox/destroy.rs b/src/jmap/mailbox/destroy.rs index 7acfe568..e8f45c38 100644 --- a/src/jmap/mailbox/destroy.rs +++ b/src/jmap/mailbox/destroy.rs @@ -3,7 +3,7 @@ use clap::Parser; use io_jmap::rfc8621::coroutines::mailbox_set::{ JmapMailboxSet, JmapMailboxSetArgs, JmapMailboxSetResult, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; diff --git a/src/jmap/mailbox/get.rs b/src/jmap/mailbox/get.rs index a2f1dda9..c350fafd 100644 --- a/src/jmap/mailbox/get.rs +++ b/src/jmap/mailbox/get.rs @@ -1,7 +1,7 @@ use anyhow::{bail, Result}; use clap::Parser; use io_jmap::rfc8621::coroutines::mailbox_get::{JmapMailboxGet, JmapMailboxGetResult}; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; diff --git a/src/jmap/mailbox/query.rs b/src/jmap/mailbox/query.rs index d6cbe7a4..c68b41c7 100644 --- a/src/jmap/mailbox/query.rs +++ b/src/jmap/mailbox/query.rs @@ -9,7 +9,7 @@ use io_jmap::{ Mailbox, MailboxFilter, MailboxRole, MailboxSortComparator, MailboxSortProperty, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; diff --git a/src/jmap/mailbox/update.rs b/src/jmap/mailbox/update.rs index 00d1436f..1c6ac44c 100644 --- a/src/jmap/mailbox/update.rs +++ b/src/jmap/mailbox/update.rs @@ -6,7 +6,7 @@ use io_jmap::{ rfc8621::coroutines::mailbox_set::{JmapMailboxSet, JmapMailboxSetArgs, JmapMailboxSetResult}, rfc8621::types::mailbox::MailboxUpdate, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::{account::JmapAccount, mailbox::query::RoleArg}; diff --git a/src/jmap/query.rs b/src/jmap/query.rs index 19dd407c..531f7139 100644 --- a/src/jmap/query.rs +++ b/src/jmap/query.rs @@ -9,7 +9,7 @@ use io_jmap::rfc8620::{ coroutines::send::{JmapRequest, JmapSend, JmapSendResult}, types::session::capabilities::{CORE, MAIL}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; use serde_json::Value; @@ -26,7 +26,7 @@ use crate::jmap::account::JmapAccount; /// automatically if not already present. Pass `-` or omit to read /// from stdin. #[derive(Debug, Parser)] -pub struct QueryCommand { +pub struct JmapQueryCommand { /// Extra capability URNs to declare (core and mail are always included). #[arg(long = "using", value_name = "URN")] pub using: Vec, @@ -37,7 +37,7 @@ pub struct QueryCommand { pub method_calls: Vec, } -impl QueryCommand { +impl JmapQueryCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/submission/cancel.rs b/src/jmap/submission/cancel.rs index 9de57333..3d928b4a 100644 --- a/src/jmap/submission/cancel.rs +++ b/src/jmap/submission/cancel.rs @@ -3,7 +3,7 @@ use clap::Parser; use io_jmap::rfc8621::coroutines::email_submission_cancel::{ JmapEmailSubmissionCancel, JmapEmailSubmissionCancelResult, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; @@ -13,13 +13,13 @@ use crate::jmap::account::JmapAccount; /// Only submissions with `undoStatus: "pending"` can be canceled. /// The server may reject this if the message has already been sent. #[derive(Debug, Parser)] -pub struct CancelSubmissionCommand { +pub struct JmapSubmissionCancelCommand { /// Submission ID(s) to cancel. #[arg(value_name = "ID", required = true)] pub ids: Vec, } -impl CancelSubmissionCommand { +impl JmapSubmissionCancelCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/submission/command.rs b/src/jmap/submission/command.rs index 9fa972d4..ae208c93 100644 --- a/src/jmap/submission/command.rs +++ b/src/jmap/submission/command.rs @@ -5,27 +5,27 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{ account::JmapAccount, submission::{ - cancel::CancelSubmissionCommand, create::CreateSubmissionCommand, - get::GetSubmissionCommand, query::QuerySubmissionCommand, + cancel::JmapSubmissionCancelCommand, create::JmapSubmissionCreateCommand, + get::JmapSubmissionGetCommand, query::JmapSubmissionQueryCommand, }, }; /// Manage JMAP email submissions. #[derive(Debug, Subcommand)] -pub enum SubmissionCommand { +pub enum JmapSubmissionCommand { /// Fetch submissions by ID (EmailSubmission/get). - Get(GetSubmissionCommand), + Get(JmapSubmissionGetCommand), /// Query and list submissions (EmailSubmission/query + EmailSubmission/get). #[command(aliases = ["lst", "list"])] - Query(QuerySubmissionCommand), + Query(JmapSubmissionQueryCommand), /// Submit a draft email for sending (EmailSubmission/set). #[command(aliases = ["send", "submit"])] - Create(CreateSubmissionCommand), + Create(JmapSubmissionCreateCommand), /// Cancel a pending submission (EmailSubmission/set). - Cancel(CancelSubmissionCommand), + Cancel(JmapSubmissionCancelCommand), } -impl SubmissionCommand { +impl JmapSubmissionCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/jmap/submission/create.rs b/src/jmap/submission/create.rs index a725c803..853b91e6 100644 --- a/src/jmap/submission/create.rs +++ b/src/jmap/submission/create.rs @@ -10,7 +10,7 @@ use io_jmap::{ EmailAddressWithParameters, EmailSubmissionCreate, Envelope, }, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{account::JmapAccount, submission::query::SubmissionsTable}; @@ -20,7 +20,7 @@ use crate::jmap::{account::JmapAccount, submission::query::SubmissionsTable}; /// The email must already exist as a draft in the JMAP account. /// This is the JMAP equivalent of SMTP message submission. #[derive(Debug, Parser)] -pub struct CreateSubmissionCommand { +pub struct JmapSubmissionCreateCommand { /// The ID of the draft email to send. #[arg(value_name = "EMAIL_ID")] pub email_id: String, @@ -38,7 +38,7 @@ pub struct CreateSubmissionCommand { pub rcpt_to: Vec, } -impl CreateSubmissionCommand { +impl JmapSubmissionCreateCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/submission/get.rs b/src/jmap/submission/get.rs index 8257175e..357a12ae 100644 --- a/src/jmap/submission/get.rs +++ b/src/jmap/submission/get.rs @@ -3,7 +3,7 @@ use clap::Parser; use io_jmap::rfc8621::coroutines::email_submission_get::{ JmapEmailSubmissionGet, JmapEmailSubmissionGetResult, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; @@ -11,13 +11,13 @@ use crate::jmap::{account::JmapAccount, submission::query::SubmissionsTable}; /// Get JMAP email submissions by ID (EmailSubmission/get). #[derive(Debug, Parser)] -pub struct GetSubmissionCommand { +pub struct JmapSubmissionGetCommand { /// Submission ID(s) to retrieve. #[arg(value_name = "ID", required = true)] pub ids: Vec, } -impl GetSubmissionCommand { +impl JmapSubmissionGetCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/submission/query.rs b/src/jmap/submission/query.rs index fc4bab48..46310a04 100644 --- a/src/jmap/submission/query.rs +++ b/src/jmap/submission/query.rs @@ -9,7 +9,7 @@ use io_jmap::{ }, rfc8621::types::email_submission::{EmailSubmission, EmailSubmissionFilter, UndoStatus}, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -35,7 +35,7 @@ impl From for UndoStatus { /// Query JMAP email submissions (EmailSubmission/query + EmailSubmission/get). #[derive(Debug, Parser)] -pub struct QuerySubmissionCommand { +pub struct JmapSubmissionQueryCommand { /// Filter by undo status (`pending`, `final`, `canceled`). #[arg(long, value_name = "STATUS")] pub undo_status: Option, @@ -57,7 +57,7 @@ pub struct QuerySubmissionCommand { pub page: u64, } -impl QuerySubmissionCommand { +impl JmapSubmissionQueryCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/thread/command.rs b/src/jmap/thread/command.rs index 2e9cfdbf..5000812b 100644 --- a/src/jmap/thread/command.rs +++ b/src/jmap/thread/command.rs @@ -2,16 +2,16 @@ use anyhow::Result; use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; -use crate::jmap::{account::JmapAccount, thread::get::GetThreadCommand}; +use crate::jmap::{account::JmapAccount, thread::get::JmapThreadGetCommand}; /// Manage JMAP threads. #[derive(Debug, Subcommand)] -pub enum ThreadCommand { +pub enum JmapThreadCommand { /// Fetch threads by ID (Thread/get). - Get(GetThreadCommand), + Get(JmapThreadGetCommand), } -impl ThreadCommand { +impl JmapThreadCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/jmap/thread/get.rs b/src/jmap/thread/get.rs index 2ff6f6a3..2a64196e 100644 --- a/src/jmap/thread/get.rs +++ b/src/jmap/thread/get.rs @@ -7,7 +7,7 @@ use io_jmap::{ rfc8621::coroutines::thread_get::{JmapThreadGet, JmapThreadGetResult}, rfc8621::types::thread::Thread, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use log::warn; use pimalaya_toolbox::terminal::printer::Printer; use serde::Serialize; @@ -18,13 +18,13 @@ use crate::jmap::account::JmapAccount; /// /// Each thread contains an ordered list of email IDs in the thread. #[derive(Debug, Parser)] -pub struct GetThreadCommand { +pub struct JmapThreadGetCommand { /// Thread ID(s) to retrieve. #[arg(value_name = "ID", required = true)] pub ids: Vec, } -impl GetThreadCommand { +impl JmapThreadGetCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/vacation/command.rs b/src/jmap/vacation/command.rs index 14b0bbd4..6326e87a 100644 --- a/src/jmap/vacation/command.rs +++ b/src/jmap/vacation/command.rs @@ -4,19 +4,19 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::jmap::{ account::JmapAccount, - vacation::{get::GetVacationCommand, set::SetVacationCommand}, + vacation::{get::JmapVacationGetCommand, set::JmapVacationSetCommand}, }; /// Manage JMAP vacation response. #[derive(Debug, Subcommand)] -pub enum VacationCommand { +pub enum JmapVacationCommand { /// Get the vacation response (VacationResponse/get). - Get(GetVacationCommand), + Get(JmapVacationGetCommand), /// Update the vacation response (VacationResponse/set). - Set(SetVacationCommand), + Set(JmapVacationSetCommand), } -impl VacationCommand { +impl JmapVacationCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/jmap/vacation/get.rs b/src/jmap/vacation/get.rs index fe47464c..bd698f66 100644 --- a/src/jmap/vacation/get.rs +++ b/src/jmap/vacation/get.rs @@ -10,7 +10,7 @@ use io_jmap::{ }, rfc8621::types::vacation_response::VacationResponse, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use serde::Serialize; @@ -18,9 +18,9 @@ use crate::jmap::account::JmapAccount; /// Get the JMAP vacation response (VacationResponse/get). #[derive(Debug, Parser)] -pub struct GetVacationCommand; +pub struct JmapVacationGetCommand; -impl GetVacationCommand { +impl JmapVacationGetCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/jmap/vacation/set.rs b/src/jmap/vacation/set.rs index 4cc1c7d1..f948fe3d 100644 --- a/src/jmap/vacation/set.rs +++ b/src/jmap/vacation/set.rs @@ -7,14 +7,14 @@ use io_jmap::{ }, rfc8621::types::vacation_response::VacationResponseUpdate, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use pimalaya_toolbox::terminal::printer::{Message, Printer}; use crate::jmap::account::JmapAccount; /// Update the JMAP vacation response (VacationResponse/set). #[derive(Debug, Parser)] -pub struct SetVacationCommand { +pub struct JmapVacationSetCommand { /// Enable the vacation response. #[arg(long, conflicts_with = "disable")] pub enable: bool, @@ -44,7 +44,7 @@ pub struct SetVacationCommand { pub html_body: Option, } -impl SetVacationCommand { +impl JmapVacationSetCommand { pub fn execute(self, printer: &mut impl Printer, account: JmapAccount) -> Result<()> { let mut jmap = account.new_jmap_session()?; diff --git a/src/maildir/command.rs b/src/maildir/command.rs index 5cd4c473..66e9ee89 100644 --- a/src/maildir/command.rs +++ b/src/maildir/command.rs @@ -3,9 +3,10 @@ use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; use crate::maildir::{ - account::MaildirAccount, create::CreateMaildirCommand, delete::DeleteMaildirCommand, - envelope::command::EnvelopesCommand, flag::command::FlagCommand, list::ListMaildirsCommand, - message::command::MessageCommand, rename::RenameMaildirCommand, + account::MaildirAccount, create::MaildirMailboxCreateCommand, + delete::MaildirMailboxDeleteCommand, envelope::command::MaildirEnvelopeCommand, + flag::command::MaildirFlagCommand, list::MaildirMailboxListCommand, + message::command::MaildirMessageCommand, rename::MaildirMailboxRenameCommand, }; /// MAILDIR CLI (requires the `maildir` cargo feature). @@ -15,18 +16,18 @@ use crate::maildir::{ #[derive(Debug, Subcommand)] #[command(rename_all = "kebab-case")] pub enum MaildirCommand { - Create(CreateMaildirCommand), - Rename(RenameMaildirCommand), - Delete(DeleteMaildirCommand), - List(ListMaildirsCommand), + Create(MaildirMailboxCreateCommand), + Rename(MaildirMailboxRenameCommand), + Delete(MaildirMailboxDeleteCommand), + List(MaildirMailboxListCommand), #[command(subcommand)] #[command(aliases = ["msgs", "msg"])] - Messages(MessageCommand), + Messages(MaildirMessageCommand), #[command(subcommand)] - Flags(FlagCommand), + Flags(MaildirFlagCommand), #[command(subcommand)] - Envelopes(EnvelopesCommand), + Envelopes(MaildirEnvelopeCommand), } impl MaildirCommand { diff --git a/src/maildir/create.rs b/src/maildir/create.rs index e71f6ef8..f6c6ae69 100644 --- a/src/maildir/create.rs +++ b/src/maildir/create.rs @@ -11,12 +11,12 @@ use crate::maildir::{account::MaildirAccount, arg::MaildirNameArg}; /// This command allows you to create a new mailbox using the given /// name. #[derive(Debug, Parser)] -pub struct CreateMaildirCommand { +pub struct MaildirMailboxCreateCommand { #[command(flatten)] pub maildir_name: MaildirNameArg, } -impl CreateMaildirCommand { +impl MaildirMailboxCreateCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let path = account.backend.root.join(self.maildir_name.inner); diff --git a/src/maildir/delete.rs b/src/maildir/delete.rs index 74f5324e..14b1988d 100644 --- a/src/maildir/delete.rs +++ b/src/maildir/delete.rs @@ -11,12 +11,12 @@ use crate::maildir::{account::MaildirAccount, arg::MaildirPathFlag}; /// This command allows you to delete a new mailbox using the given /// name. #[derive(Debug, Parser)] -pub struct DeleteMaildirCommand { +pub struct MaildirMailboxDeleteCommand { #[command(flatten)] pub maildir_path: MaildirPathFlag, } -impl DeleteMaildirCommand { +impl MaildirMailboxDeleteCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let path = account.backend.root.join(self.maildir_path.inner); diff --git a/src/maildir/envelope/command.rs b/src/maildir/envelope/command.rs index 06c89d42..2839396a 100644 --- a/src/maildir/envelope/command.rs +++ b/src/maildir/envelope/command.rs @@ -4,7 +4,7 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::maildir::{ account::MaildirAccount, - envelope::{get::GetEnvelopeCommand, list::ListEnvelopesCommand}, + envelope::{get::MaildirEnvelopeGetCommand, list::MaildirEnvelopeListCommand}, }; /// Manage MAILDIR envelopes. @@ -13,12 +13,12 @@ use crate::maildir::{ /// date, subject, from, to, cc, bcc, etc. This subcommand allows you /// to get, list, search, sort, and thread envelopes. #[derive(Debug, Subcommand)] -pub enum EnvelopesCommand { - Get(GetEnvelopeCommand), - List(ListEnvelopesCommand), +pub enum MaildirEnvelopeCommand { + Get(MaildirEnvelopeGetCommand), + List(MaildirEnvelopeListCommand), } -impl EnvelopesCommand { +impl MaildirEnvelopeCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { match self { Self::Get(cmd) => cmd.execute(printer, account), diff --git a/src/maildir/envelope/get.rs b/src/maildir/envelope/get.rs index 1d642c59..a1a19b5e 100644 --- a/src/maildir/envelope/get.rs +++ b/src/maildir/envelope/get.rs @@ -20,14 +20,14 @@ use crate::maildir::{ /// message, including all header fields like date, subject, from, to, /// cc, bcc, reply-to, message-id, and in-reply-to. #[derive(Debug, Parser)] -pub struct GetEnvelopeCommand { +pub struct MaildirEnvelopeGetCommand { #[command(flatten)] pub maildir: MaildirPathFlag, #[command(flatten)] pub id: MessageIdArg, } -impl GetEnvelopeCommand { +impl MaildirEnvelopeGetCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/envelope/list.rs b/src/maildir/envelope/list.rs index e5b4652e..f6812e4c 100644 --- a/src/maildir/envelope/list.rs +++ b/src/maildir/envelope/list.rs @@ -16,12 +16,12 @@ use crate::maildir::{account::MaildirAccount, arg::MaildirPathFlag}; /// mailbox. You can specify a sequence set to limit which messages /// are fetched. #[derive(Debug, Parser)] -pub struct ListEnvelopesCommand { +pub struct MaildirEnvelopeListCommand { #[command(flatten)] pub maildir: MaildirPathFlag, } -impl ListEnvelopesCommand { +impl MaildirEnvelopeListCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/flag/add.rs b/src/maildir/flag/add.rs index 47a26332..982c2e04 100644 --- a/src/maildir/flag/add.rs +++ b/src/maildir/flag/add.rs @@ -15,7 +15,7 @@ use crate::maildir::{ /// This command adds the given flags to messages identified by the /// given sequence set. #[derive(Debug, Parser)] -pub struct AddFlagsCommand { +pub struct MaildirFlagAddCommand { #[command(flatten)] pub ids: MessageIdsArg, @@ -26,7 +26,7 @@ pub struct AddFlagsCommand { pub flags: Vec, } -impl AddFlagsCommand { +impl MaildirFlagAddCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/flag/command.rs b/src/maildir/flag/command.rs index e203dc11..91ce541c 100644 --- a/src/maildir/flag/command.rs +++ b/src/maildir/flag/command.rs @@ -5,8 +5,8 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::maildir::{ account::MaildirAccount, flag::{ - add::AddFlagsCommand, list::ListFlagsCommand, remove::RemoveFlagsCommand, - set::SetFlagsCommand, + add::MaildirFlagAddCommand, list::MaildirFlagListCommand, remove::MaildirFlagRemoveCommand, + set::MaildirFlagSetCommand, }, }; @@ -15,14 +15,14 @@ use crate::maildir::{ /// A flag is a label attached to a message. This subcommand allows /// you to manage them. #[derive(Debug, Subcommand)] -pub enum FlagCommand { - List(ListFlagsCommand), - Add(AddFlagsCommand), - Set(SetFlagsCommand), - Remove(RemoveFlagsCommand), +pub enum MaildirFlagCommand { + List(MaildirFlagListCommand), + Add(MaildirFlagAddCommand), + Set(MaildirFlagSetCommand), + Remove(MaildirFlagRemoveCommand), } -impl FlagCommand { +impl MaildirFlagCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { match self { Self::List(cmd) => cmd.execute(printer, account), diff --git a/src/maildir/flag/list.rs b/src/maildir/flag/list.rs index 5c523afa..91f9cdf4 100644 --- a/src/maildir/flag/list.rs +++ b/src/maildir/flag/list.rs @@ -15,9 +15,9 @@ use crate::maildir::account::MaildirAccount; /// available in the given mailbox. These flags come from the SELECT /// response. #[derive(Debug, Parser)] -pub struct ListFlagsCommand; +pub struct MaildirFlagListCommand; -impl ListFlagsCommand { +impl MaildirFlagListCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let table = FlagsTable { preset: account.table_preset, diff --git a/src/maildir/flag/remove.rs b/src/maildir/flag/remove.rs index fc77417f..9e4def47 100644 --- a/src/maildir/flag/remove.rs +++ b/src/maildir/flag/remove.rs @@ -15,7 +15,7 @@ use crate::maildir::{ /// This command removes the given flags to messages identified by the /// given sequence set. #[derive(Debug, Parser)] -pub struct RemoveFlagsCommand { +pub struct MaildirFlagRemoveCommand { #[command(flatten)] pub ids: MessageIdsArg, @@ -26,7 +26,7 @@ pub struct RemoveFlagsCommand { pub flags: Vec, } -impl RemoveFlagsCommand { +impl MaildirFlagRemoveCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/flag/set.rs b/src/maildir/flag/set.rs index b2d44025..9ca17cb4 100644 --- a/src/maildir/flag/set.rs +++ b/src/maildir/flag/set.rs @@ -15,7 +15,7 @@ use crate::maildir::{ /// This command sets the given flags to messages identified by the /// given sequence set. #[derive(Debug, Parser)] -pub struct SetFlagsCommand { +pub struct MaildirFlagSetCommand { #[command(flatten)] pub ids: MessageIdsArg, @@ -26,7 +26,7 @@ pub struct SetFlagsCommand { pub flags: Vec, } -impl SetFlagsCommand { +impl MaildirFlagSetCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/list.rs b/src/maildir/list.rs index c217b34c..d2d27218 100644 --- a/src/maildir/list.rs +++ b/src/maildir/list.rs @@ -16,9 +16,9 @@ use crate::maildir::account::MaildirAccount; /// By default, only subscribed maildirs are listed. Use --all to /// list all maildirs. #[derive(Debug, Parser)] -pub struct ListMaildirsCommand; +pub struct MaildirMailboxListCommand; -impl ListMaildirsCommand { +impl MaildirMailboxListCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let mut arg = None; let mut coroutine = ListMaildirs::new(account.backend.root); diff --git a/src/maildir/message/command.rs b/src/maildir/message/command.rs index 0ef5e087..694af74f 100644 --- a/src/maildir/message/command.rs +++ b/src/maildir/message/command.rs @@ -5,8 +5,9 @@ use pimalaya_toolbox::terminal::printer::Printer; use crate::maildir::{ account::MaildirAccount, message::{ - copy::CopyMessagesCommand, export::ExportMessageCommand, get::GetMessageCommand, - r#move::MoveMessagesCommand, read::ReadMessageCommand, save::SaveMessageCommand, + copy::MaildirMessageCopyCommand, export::MaildirMessageExportCommand, + get::MaildirMessageGetCommand, r#move::MaildirMessageMoveCommand, + read::MaildirMessageReadCommand, save::MaildirMessageSaveCommand, }, }; @@ -16,16 +17,16 @@ use crate::maildir::{ /// subcommand allows you to save, get, read, export, copy, and move /// messages. #[derive(Debug, Subcommand)] -pub enum MessageCommand { - Save(SaveMessageCommand), - Get(GetMessageCommand), - Read(ReadMessageCommand), - Export(ExportMessageCommand), - Copy(CopyMessagesCommand), - Move(MoveMessagesCommand), +pub enum MaildirMessageCommand { + Save(MaildirMessageSaveCommand), + Get(MaildirMessageGetCommand), + Read(MaildirMessageReadCommand), + Export(MaildirMessageExportCommand), + Copy(MaildirMessageCopyCommand), + Move(MaildirMessageMoveCommand), } -impl MessageCommand { +impl MaildirMessageCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { match self { Self::Save(cmd) => cmd.execute(printer, account), diff --git a/src/maildir/message/copy.rs b/src/maildir/message/copy.rs index bf30a5dd..84eff867 100644 --- a/src/maildir/message/copy.rs +++ b/src/maildir/message/copy.rs @@ -14,7 +14,7 @@ use crate::maildir::{ /// This command copies message(s) identified by the given sequence /// set from the source mailbox to the destination mailbox. #[derive(Debug, Parser)] -pub struct CopyMessagesCommand { +pub struct MaildirMessageCopyCommand { #[command(flatten)] pub ids: MessageIdsArg, #[command(flatten)] @@ -27,7 +27,7 @@ pub struct CopyMessagesCommand { pub subdir: Option, } -impl CopyMessagesCommand { +impl MaildirMessageCopyCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let source = match Maildir::try_from(self.source.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/message/export.rs b/src/maildir/message/export.rs index 5a257b7d..926cde76 100644 --- a/src/maildir/message/export.rs +++ b/src/maildir/message/export.rs @@ -21,7 +21,7 @@ use crate::maildir::{ /// - eml: Save as .eml file /// - parts: Export all MIME parts to separate files #[derive(Debug, Parser)] -pub struct ExportMessageCommand { +pub struct MaildirMessageExportCommand { #[command(flatten)] pub maildir: MaildirPathFlag, #[command(flatten)] @@ -40,7 +40,7 @@ pub struct ExportMessageCommand { pub open: bool, } -impl ExportMessageCommand { +impl MaildirMessageExportCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/message/get.rs b/src/maildir/message/get.rs index 37618bb8..ba141586 100644 --- a/src/maildir/message/get.rs +++ b/src/maildir/message/get.rs @@ -17,14 +17,14 @@ use crate::maildir::{ /// This command copies message(s) identified by the given sequence /// set from the source mailbox to the destination mailbox. #[derive(Debug, Parser)] -pub struct GetMessageCommand { +pub struct MaildirMessageGetCommand { #[command(flatten)] pub maildir: MaildirPathFlag, #[command(flatten)] pub id: MessageIdArg, } -impl GetMessageCommand { +impl MaildirMessageGetCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/message/move.rs b/src/maildir/message/move.rs index 2d3a323b..29a79b72 100644 --- a/src/maildir/message/move.rs +++ b/src/maildir/message/move.rs @@ -14,7 +14,7 @@ use crate::maildir::{ /// This command copies message(s) identified by the given sequence /// set from the source mailbox to the destination mailbox. #[derive(Debug, Parser)] -pub struct MoveMessagesCommand { +pub struct MaildirMessageMoveCommand { #[command(flatten)] pub ids: MessageIdsArg, #[command(flatten)] @@ -27,7 +27,7 @@ pub struct MoveMessagesCommand { pub subdir: Option, } -impl MoveMessagesCommand { +impl MaildirMessageMoveCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let source = match Maildir::try_from(self.source.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/message/read.rs b/src/maildir/message/read.rs index 688212d4..fdb0e3a6 100644 --- a/src/maildir/message/read.rs +++ b/src/maildir/message/read.rs @@ -17,7 +17,7 @@ use crate::maildir::{ /// This command fetches a message and displays its text content. /// By default it shows plain text content; use --html to show HTML. #[derive(Debug, Parser)] -pub struct ReadMessageCommand { +pub struct MaildirMessageReadCommand { #[command(flatten)] pub maildir: MaildirPathFlag, #[command(flatten)] @@ -31,7 +31,7 @@ pub struct ReadMessageCommand { pub width: usize, } -impl ReadMessageCommand { +impl MaildirMessageReadCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/message/save.rs b/src/maildir/message/save.rs index 0243c84e..e45dd628 100644 --- a/src/maildir/message/save.rs +++ b/src/maildir/message/save.rs @@ -22,7 +22,7 @@ use crate::maildir::{ /// This command appends a message to the specified mailbox. The /// message is read from stdin in RFC 5322 format (raw email). #[derive(Debug, Parser)] -pub struct SaveMessageCommand { +pub struct MaildirMessageSaveCommand { #[command(flatten)] pub maildir: MaildirPathFlag, @@ -41,7 +41,7 @@ pub struct SaveMessageCommand { pub message: Vec, } -impl SaveMessageCommand { +impl MaildirMessageSaveCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let maildir = match Maildir::try_from(self.maildir.inner.clone()) { Ok(maildir) => maildir, diff --git a/src/maildir/rename.rs b/src/maildir/rename.rs index 5c9b44ab..9876739c 100644 --- a/src/maildir/rename.rs +++ b/src/maildir/rename.rs @@ -14,14 +14,14 @@ use crate::maildir::{ /// This command allows you to rename a new mailbox using the given /// name. #[derive(Debug, Parser)] -pub struct RenameMaildirCommand { +pub struct MaildirMailboxRenameCommand { #[command(flatten)] pub maildir_path: MaildirPathFlag, #[command(flatten)] pub maildir_name: MaildirNameArg, } -impl RenameMaildirCommand { +impl MaildirMailboxRenameCommand { pub fn execute(self, printer: &mut impl Printer, account: MaildirAccount) -> Result<()> { let path = account.backend.root.join(self.maildir_path.inner); diff --git a/src/smtp/command.rs b/src/smtp/command.rs index b2bc13f2..19e8089f 100644 --- a/src/smtp/command.rs +++ b/src/smtp/command.rs @@ -2,7 +2,7 @@ use anyhow::Result; use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; -use crate::smtp::{account::SmtpAccount, message::command::MessageCommand}; +use crate::smtp::{account::SmtpAccount, message::command::SmtpMessageCommand}; /// SMTP CLI (requires `smtp` cargo feature). /// @@ -14,7 +14,7 @@ use crate::smtp::{account::SmtpAccount, message::command::MessageCommand}; pub enum SmtpCommand { #[command(subcommand)] #[command(aliases = ["msgs", "msg"])] - Messages(MessageCommand), + Messages(SmtpMessageCommand), } impl SmtpCommand { diff --git a/src/smtp/message/command.rs b/src/smtp/message/command.rs index 55bbd241..4f79b9ba 100644 --- a/src/smtp/message/command.rs +++ b/src/smtp/message/command.rs @@ -2,7 +2,7 @@ use anyhow::Result; use clap::Subcommand; use pimalaya_toolbox::terminal::printer::Printer; -use crate::smtp::{account::SmtpAccount, message::send::SendMessageCommand}; +use crate::smtp::{account::SmtpAccount, message::send::SmtpMessageSendCommand}; /// Manage messages. /// @@ -10,11 +10,11 @@ use crate::smtp::{account::SmtpAccount, message::send::SendMessageCommand}; /// subcommand allows you to save, get, read, export, copy, move, and /// delete messages. #[derive(Debug, Subcommand)] -pub enum MessageCommand { - Send(SendMessageCommand), +pub enum SmtpMessageCommand { + Send(SmtpMessageSendCommand), } -impl MessageCommand { +impl SmtpMessageCommand { pub fn execute(self, printer: &mut impl Printer, account: SmtpAccount) -> Result<()> { match self { Self::Send(cmd) => cmd.execute(printer, account), diff --git a/src/smtp/message/send.rs b/src/smtp/message/send.rs index 58d23bdc..043c31fa 100644 --- a/src/smtp/message/send.rs +++ b/src/smtp/message/send.rs @@ -11,9 +11,9 @@ use io_smtp::{ domain::Domain, ehlo_domain::EhloDomain, forward_path::ForwardPath, local_part::LocalPart, mailbox::Mailbox, reverse_path::ReversePath, }, - send_message::*, + send::*, }; -use io_stream::runtimes::std::handle; +use io_socket::runtimes::std_stream::handle; use mail_parser::{Addr, Address, HeaderName, HeaderValue, MessageParser}; use pimalaya_toolbox::terminal::printer::{Message, Printer}; @@ -24,14 +24,14 @@ use crate::smtp::account::SmtpAccount; /// This command appends a message to the specified mailbox. The /// message is read from stdin in RFC 5322 format (raw email). #[derive(Debug, Parser)] -pub struct SendMessageCommand { +pub struct SmtpMessageSendCommand { /// The raw message, including headers and body. #[arg(trailing_var_arg = true)] #[arg(name = "message", value_name = "MESSAGE")] pub message: Vec, } -impl SendMessageCommand { +impl SmtpMessageSendCommand { pub fn execute(self, printer: &mut impl Printer, account: SmtpAccount) -> Result<()> { let mut imap = account.new_smtp_session()?; @@ -52,13 +52,13 @@ impl SendMessageCommand { let (reverse_path, forward_paths) = into_smtp_msg(message.as_bytes())?; let mut arg = None; - let mut coroutine = SendSmtpMessage::new(reverse_path, forward_paths, message.into_bytes()); + let mut coroutine = SmtpMessageSend::new(reverse_path, forward_paths, message.into_bytes()); loop { match coroutine.resume(arg.take()) { - SendSmtpMessageResult::Io { io } => arg = Some(handle(&mut imap.stream, io)?), - SendSmtpMessageResult::Ok => break, - SendSmtpMessageResult::Err { err } => bail!(err), + SmtpMessageSendResult::Io { input } => arg = Some(handle(&mut imap.stream, input)?), + SmtpMessageSendResult::Ok => break, + SmtpMessageSendResult::Err { err } => bail!(err), } }