3d24964 chore: Update dependencies — radicle-tui

radicle-tui

rad:z39mP9rQAaGmERfUMPULfPUi473tY

Radicle terminal user interface

chore: Update dependencies

Erik Kundt committed 4 months ago

commit 3d24964a24b01947fc40cbb4d371cc101fef8111
parent 6027d8e

5 files changed +92 -85

modified 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",

@@ -1418,17 +1418,6 @@ dependencies = [

 ]
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -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"

@@ -1722,6 +1711,15 @@ dependencies = [

 ]
 [[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"
 source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -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",

@@ -2809,12 +2807,6 @@ 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"
 source = "registry+https://github.com/rust-lang/crates.io-index"

@@ -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",

modified 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" }
 nom = { version = "^7.0.0" }
 log = { version = "0.4.29" }
 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" }
 thiserror = { version = "2.0.16" }
 tokio = { version = "1.32.0", features = ["full"] }
 terminal-light = { version = "1.8.0" }
 thiserror = { version = "2.0.17" }
 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"]

modified 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::IResult;
     use nom::sequence::delimited;
     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(' ');

modified 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> {

modified 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> {