chore: Update dependencies

Cargo.lock

@@ -134,7 +134,7 @@ version = "7.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67555e1f1ece39d737e28c8a017721287753af3f93225e4a445b29ccb0f5912c"
 dependencies = [
- "nom",
+ "nom 7.1.3",
  "ratatui",
  "simdutf8",
  "smallvec",
@@ -1417,17 +1417,6 @@ dependencies = [
  "syn 2.0.106",
 ]
 
-[[package]]
-name = "io-uring"
-version = "0.7.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "046fa2d4d00aea763528b4950358d0ead425372445dc8ff86312b3c69ff7727b"
-dependencies = [
- "bitflags 2.9.3",
- "cfg-if",
- "libc",
-]
-
 [[package]]
 name = "is_terminal_polyfill"
 version = "1.70.2"
@@ -1603,9 +1592,9 @@ dependencies = [
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
 
 [[package]]
 name = "lru"
@@ -1721,6 +1710,15 @@ dependencies = [
  "minimal-lexical",
 ]
 
+[[package]]
+name = "nom"
+version = "8.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df9761775871bdef83bee530e60050f7e54b1105350d6884eb0fb4f46c2f9405"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "nonempty"
 version = "0.9.0"
@@ -2356,7 +2354,7 @@ dependencies = [
  "lexopt",
  "log",
  "md5",
- "nom",
+ "nom 8.0.0",
  "pretty_assertions",
  "radicle",
  "radicle-cli",
@@ -2368,7 +2366,7 @@ dependencies = [
  "serde_json",
  "simple-logging",
  "terminal-light",
- "thiserror 2.0.16",
+ "thiserror 2.0.17",
  "timeago 0.5.0",
  "tokio",
  "tokio-util",
@@ -2808,12 +2806,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
-[[package]]
-name = "slab"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
-
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -3073,11 +3065,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3467d614147380f2e4e374161426ff399c91084acd2363eaf549172b3d5e60c0"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl 2.0.16",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
@@ -3093,9 +3085,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.16"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c5e1be1c48b9172ee610da68fd9cd2770e7a4056cb3fc98710ee6906f0c7960"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3197,29 +3189,26 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "tokio"
-version = "1.47.1"
+version = "1.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89e49afdadebb872d3145a5638b59eb0691ea23e46ca484037cfab3b76b95038"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
 dependencies = [
- "backtrace",
  "bytes",
- "io-uring",
  "libc",
  "mio 1.0.4",
  "parking_lot",
  "pin-project-lite",
  "signal-hook-registry",
- "slab",
  "socket2",
  "tokio-macros",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "tokio-macros"
-version = "2.5.0"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e06d43f1345a3bcd39f6a56dbb7dcab2ba47e68e8ac134855e7e2bdbaf8cab8"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
  "proc-macro2",
  "quote",

Cargo.toml

@@ -24,16 +24,16 @@ required-features = ["bin"]
 [dependencies]
 ansi-to-tui = { version = "7.0.0" }
 anyhow = { version = "1" }
-lexopt = { version = "0.3.0" }
+lexopt = { version = "0.3.1" }
 fuzzy-matcher = "0.3.7"
-homedir = { version = "0.3.3" }
+homedir = { version = "0.3.6" }
 lazy_static = { version = "1.5.0" }
-log = { version = "0.4.19" }
+log = { version = "0.4.29" }
-nom = { version = "^7.0.0" }
+nom = { version = "^8.0.0" }
 radicle = { version = "0.20.0" }
 radicle-term = { version = "0.16.0" }
 radicle-cli = { version = "0.17.0" }
-radicle-surf = { version = "0.22.0" }
+radicle-surf = { version = "0.22.1" }
 ratatui = { version = "0.29.0", default-features = false, features = [
     "all-widgets",
     "crossterm",
@@ -44,14 +44,14 @@ simple-logging = { version = "2.0.2" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = { version = "1.0" }
 timeago = { version = "0.5.0" }
-terminal-light = { version = "1.4.0" }
+terminal-light = { version = "1.8.0" }
-thiserror = { version = "2.0.16" }
+thiserror = { version = "2.0.17" }
-tokio = { version = "1.32.0", features = ["full"] }
+tokio = { version = "1.48.0", features = ["full"] }
 tokio-util = { version = "0.7.17" }
 tui-textarea = { version = "0.7.0", default-features = false, features = [
     "crossterm",
 ] }
-tui-tree-widget = { version = "0.23.0" }
+tui-tree-widget = { version = "0.23.1" }
 
 [dev-dependencies]
 pretty_assertions = "^1.4.1"
@@ -60,6 +60,6 @@ radicle-git-ext = { version = "0.8.1", features = ["serde"] }
 
 
 [dev-dependencies.git2]
-version = "0.19.0"
+version = "0.19"
 default-features = false
 features = ["vendored-libgit2"]

bin/ui/items.rs

@@ -40,8 +40,8 @@ pub mod filter {
     use nom::character::complete::{char, multispace0};
     use nom::combinator::map;
     use nom::multi::separated_list1;
-    use nom::sequence::{delimited, tuple};
+    use nom::sequence::delimited;
-    use nom::IResult;
+    use nom::{IResult, Parser};
 
     use radicle::prelude::Did;
 
@@ -94,12 +94,12 @@ pub mod filter {
     pub fn parse_did_or(input: &str) -> IResult<&str, DidFilter> {
         map(
             delimited(
-                tuple((multispace0, char('('), multispace0)),
+                (multispace0, char('('), multispace0),
                 separated_list1(
                     delimited(multispace0, tag_no_case("or"), multispace0),
                     take(56_usize),
                 ),
-                tuple((multispace0, char(')'), multispace0)),
+                (multispace0, char(')'), multispace0),
             ),
             |dids: Vec<&str>| {
                 DidFilter::Or(
@@ -108,7 +108,8 @@ pub mod filter {
                         .collect::<Vec<_>>(),
                 )
             },
-        )(input)
+        )
+        .parse(input)
     }
 }
 
@@ -368,7 +369,8 @@ impl FromStr for IssueItemFilter {
                     separated_list0(tag(","), take(56_usize)),
                     tag("]"),
                 ),
-            )(input)
+            )
+            .parse(input)
         };
 
         let mut assignees_parser = |input| -> IResult<&str, Vec<&str>> {
@@ -379,7 +381,8 @@ impl FromStr for IssueItemFilter {
                     separated_list0(tag(","), take(56_usize)),
                     tag("]"),
                 ),
-            )(input)
+            )
+            .parse(input)
         };
 
         let parts = value.split(' ');

bin/ui/items/notification.rs

@@ -337,7 +337,7 @@ pub mod filter {
     use nom::character::complete::{char, multispace0};
     use nom::combinator::{map, opt, value};
     use nom::multi::{many0, separated_list1};
-    use nom::sequence::{delimited, preceded, tuple};
+    use nom::sequence::{delimited, preceded};
     use nom::IResult;
     use radicle::cob::TypeName;
 
@@ -519,11 +519,14 @@ pub mod filter {
         type Err = anyhow::Error;
 
         fn from_str(filter_exp: &str) -> Result<Self, Self::Err> {
+            use nom::Parser;
+
             fn parse_state(input: &str) -> IResult<&str, NotificationState> {
                 alt((
                     value(NotificationState::Seen, tag_no_case("seen")),
                     value(NotificationState::Unseen, tag_no_case("unseen")),
-                ))(input)
+                ))
+                .parse(input)
             }
 
             fn parse_name(input: &str) -> IResult<&str, &str> {
@@ -548,21 +551,22 @@ pub mod filter {
             fn parse_state_filter(input: &str) -> IResult<&str, NotificationFilter> {
                 map(
                     preceded(
-                        tuple((
+                        (
                             tag_no_case("state"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
-                        )),
+                        ),
                         parse_state,
                     ),
                     NotificationFilter::State,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_cob_kind(input: &str) -> IResult<&str, NotificationKind> {
                 let (input, _) = tag("cob")(input)?;
-                let (input, type_name) = opt(preceded(tag(":"), parse_type_name))(input)?;
+                let (input, type_name) = opt(preceded(tag(":"), parse_type_name)).parse(input)?;
 
                 Ok((
                     input,
@@ -577,7 +581,7 @@ pub mod filter {
 
             fn parse_branch_kind(input: &str) -> IResult<&str, NotificationKind> {
                 let (input, _) = tag("branch")(input)?;
-                let (input, name) = opt(preceded(tag(":"), parse_name))(input)?;
+                let (input, name) = opt(preceded(tag(":"), parse_name)).parse(input)?;
 
                 Ok((
                     input,
@@ -592,7 +596,7 @@ pub mod filter {
 
             fn parse_unknown_kind(input: &str) -> IResult<&str, NotificationKind> {
                 let (input, _) = tag("unknown")(input)?;
-                let (input, refname) = opt(preceded(tag(":"), parse_name))(input)?;
+                let (input, refname) = opt(preceded(tag(":"), parse_name)).parse(input)?;
 
                 Ok((
                     input,
@@ -603,62 +607,66 @@ pub mod filter {
             }
 
             fn parse_kind(input: &str) -> IResult<&str, NotificationKind> {
-                alt((parse_cob_kind, parse_branch_kind, parse_unknown_kind))(input)
+                alt((parse_cob_kind, parse_branch_kind, parse_unknown_kind)).parse(input)
             }
 
             fn parse_kind_single(input: &str) -> IResult<&str, NotificationKindFilter> {
-                map(parse_kind, NotificationKindFilter::Single)(input)
+                map(parse_kind, NotificationKindFilter::Single).parse(input)
             }
 
             fn parse_kind_or(input: &str) -> IResult<&str, NotificationKindFilter> {
                 map(
                     delimited(
-                        tuple((multispace0, char('('), multispace0)),
+                        (multispace0, char('('), multispace0),
                         separated_list1(
                             delimited(multispace0, tag_no_case("or"), multispace0),
                             parse_kind,
                         ),
-                        tuple((multispace0, char(')'), multispace0)),
+                        (multispace0, char(')'), multispace0),
                     ),
                     NotificationKindFilter::Or,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_kind_filter(input: &str) -> IResult<&str, NotificationFilter> {
                 map(
                     preceded(
-                        tuple((
+                        (
                             tag_no_case("kind"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
-                        )),
+                        ),
                         alt((parse_kind_or, parse_kind_single)),
                     ),
                     NotificationFilter::Kind,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_author_filter(input: &str) -> IResult<&str, NotificationFilter> {
                 map(
                     preceded(
-                        tuple((
+                        (
                             tag_no_case("author"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
-                        )),
+                        ),
                         alt((filter::parse_did_single, filter::parse_did_or)),
                     ),
                     NotificationFilter::Author,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_search_filter(input: &str) -> IResult<&str, NotificationFilter> {
                 map(
                     take_while1(|c: char| c.is_alphanumeric() || c == '_' || c == '-'),
                     |s: &str| NotificationFilter::Search(s.to_string()),
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_single_filter(input: &str) -> IResult<&str, NotificationFilter> {
@@ -667,11 +675,12 @@ pub mod filter {
                     parse_kind_filter,
                     parse_author_filter,
                     parse_search_filter,
-                ))(input)
+                ))
+                .parse(input)
             }
 
             fn parse_filters(input: &str) -> IResult<&str, Vec<NotificationFilter>> {
-                many0(preceded(multispace0, parse_single_filter))(input)
+                many0(preceded(multispace0, parse_single_filter)).parse(input)
             }
 
             let parse_filter_expression = |input: &str| -> Result<NotificationFilter, String> {

bin/ui/items/patch.rs

@@ -138,7 +138,7 @@ pub mod filter {
     use nom::character::complete::multispace0;
     use nom::combinator::{map, value};
     use nom::multi::many0;
-    use nom::sequence::{preceded, tuple};
+    use nom::sequence::preceded;
     use nom::IResult;
 
     use radicle::patch::Status;
@@ -247,58 +247,64 @@ pub mod filter {
         type Err = anyhow::Error;
 
         fn from_str(filter_exp: &str) -> Result<Self, Self::Err> {
+            use nom::Parser;
+
             fn parse_state(input: &str) -> IResult<&str, Status> {
                 alt((
                     value(Status::Open, tag_no_case("open")),
                     value(Status::Merged, tag_no_case("merged")),
                     value(Status::Draft, tag_no_case("draft")),
                     value(Status::Archived, tag_no_case("archived")),
-                ))(input)
+                ))
+                .parse(input)
             }
 
             fn parse_state_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     preceded(
-                        tuple((
+                        (
                             tag_no_case("state"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
-                        )),
+                        ),
                         parse_state,
                     ),
                     PatchFilter::State,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_author_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     preceded(
-                        tuple((
+                        (
                             tag_no_case("author"),
                             multispace0,
                             tag_no_case("="),
                             multispace0,
-                        )),
+                        ),
                         alt((filter::parse_did_single, filter::parse_did_or)),
                     ),
                     PatchFilter::Author,
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_search_filter(input: &str) -> IResult<&str, PatchFilter> {
                 map(
                     take_while1(|c: char| c.is_alphanumeric() || c == '_' || c == '-'),
                     |s: &str| PatchFilter::Search(s.to_string()),
-                )(input)
+                )
+                .parse(input)
             }
 
             fn parse_single_filter(input: &str) -> IResult<&str, PatchFilter> {
-                alt((parse_state_filter, parse_author_filter, parse_search_filter))(input)
+                alt((parse_state_filter, parse_author_filter, parse_search_filter)).parse(input)
             }
 
             fn parse_filters(input: &str) -> IResult<&str, Vec<PatchFilter>> {
-                many0(preceded(multispace0, parse_single_filter))(input)
+                many0(preceded(multispace0, parse_single_filter)).parse(input)
             }
 
             let parse_filter_expression = |input: &str| -> Result<PatchFilter, String> {