name = "aho-corasick"

version = "1.0.2"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"

dependencies = [

 "memchr",

]

[[package]]

version = "0.11.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"

dependencies = [

 "either",

]

[[package]]

name = "itertools"

name = "lazy-regex"

version = "3.0.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "57451d19ad5e289ff6c3d69c2a2424652995c42b79dafa11e9c4d5508c913c01"

dependencies = [

 "lazy-regex-proc_macros",

 "once_cell",

 "regex",

]

[[package]]

name = "lazy-regex-proc_macros"

version = "3.0.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "0f0a1d9139f0ee2e862e08a9c5d0ba0470f2aa21cd1e1aa1b1562f83116c725f"

dependencies = [

 "proc-macro2",

 "quote",

 "regex",

 "syn 2.0.48",

]

[[package]]

 "ratatui 0.26.1",

 "tui-realm-stdlib",

 "tuirealm",

version = "0.23.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2e2e4cd95294a85c3b4446e63ef054eea43e0205b1fd60120c16b74ff7ff96ad"

dependencies = [

 "bitflags 2.4.1",

 "cassowary",

 "indoc",

 "itertools 0.11.0",

 "paste",

 "strum 0.25.0",

 "termion 2.0.1",

 "unicode-segmentation",

 "unicode-width",

]

[[package]]

name = "ratatui"

 "itertools 0.12.1",

 "strum 0.26.1",

name = "regex"

version = "1.9.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b2eae68fc220f7cf2532e4494aded17545fce192d59cd996e0fe7887f4ceb575"

dependencies = [

 "aho-corasick",

 "memchr",

 "regex-automata",

 "regex-syntax",

]

[[package]]

name = "regex-automata"

version = "0.3.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "b7b6d6190b7594385f61bd3911cd1be99dfddcfc365a4160cc2ab5bff4aed294"

dependencies = [

 "aho-corasick",

 "memchr",

 "regex-syntax",

]

[[package]]

name = "regex-syntax"

version = "0.7.4"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"

[[package]]

version = "0.25.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"

dependencies = [

 "strum_macros 0.25.3",

]

[[package]]

name = "strum"

 "strum_macros 0.26.1",

]

[[package]]

name = "strum_macros"

version = "0.25.3"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"

dependencies = [

 "heck",

 "proc-macro2",

 "quote",

 "rustversion",

 "syn 2.0.48",

version = "2.0.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "659c1f379f3408c7e5e84c7d0da6d93404e3800b6b9d063ba24436419302ec90"

dependencies = [

 "libc",

 "numtoa",

 "redox_syscall 0.2.16",

 "redox_termios",

]

[[package]]

name = "termion"

name = "tui"

version = "0.19.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "ccdd26cbd674007e649a272da4475fb666d3aa0ad0531da7136db6fab0e5bad1"

dependencies = [

 "bitflags 1.3.2",

 "cassowary",

 "termion 1.5.6",

 "unicode-segmentation",

 "unicode-width",

]

[[package]]

name = "tui-realm-stdlib"

version = "1.3.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "a14fa5a0376ef64b93b484f811716b73422803df91c9ce7f83c50cc391230426"

dependencies = [

 "textwrap",

 "tuirealm",

 "unicode-width",

]

[[package]]

name = "tuirealm"

version = "1.9.1"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "412447298ad477c25ff50c4a894ff5077b6ee3e25b913d42db30021d81b1af53"

dependencies = [

 "bitflags 2.4.1",

 "lazy-regex",

 "ratatui 0.23.0",

 "termion 2.0.1",

 "thiserror",

 "tui",

 "tuirealm_derive",

]

[[package]]

name = "tuirealm_derive"

version = "1.0.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "e0adcdaf59881626555558eae08f8a53003c8a1961723b4d7a10c51599abbc81"

dependencies = [

 "proc-macro2",

 "quote",

 "syn 1.0.109",

]

[[package]]

[features]

default = ["flux"]

realm = ["dep:tuirealm", "dep:tui-realm-stdlib"]

flux = ["dep:tokio", "dep:tokio-stream"]

tokio = { version = "1.32.0", features = ["full"], optional = true }

tokio-stream = { version = "0.1.14", optional = true }

tuirealm = { version = "^1.9.0", default-features = false, features = ["termion", "ratatui", "derive"], optional = true }

tui-realm-stdlib = { version = "1.3.1", default-features = false, features = ["termion", "ratatui"], optional = true }

pub mod cob;

pub mod context;

pub mod log;

use std::str::FromStr;

use anyhow::Result;

use radicle::cob::Label;

use radicle::prelude::Did;

pub mod inbox;

pub mod issue;

pub mod patch;

pub fn parse_labels(input: String) -> Result<Vec<Label>> {

    let mut labels = vec![];

    if !input.is_empty() {

        for name in input.split(',') {

            match Label::new(name.trim()) {

                Ok(label) => labels.push(label),

                Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse labels.")),

            }

        }

    }

    Ok(labels)

}

pub fn parse_assignees(input: String) -> Result<Vec<Did>> {

    let mut assignees = vec![];

    if !input.is_empty() {

        for did in input.split(',') {

            match Did::from_str(&format!("did:key:{}", did)) {

                Ok(did) => assignees.push(did),

                Err(err) => return Err(anyhow::anyhow!(err).context("Can't parse assignees.")),

            }

        }

    }

    Ok(assignees)

}

use anyhow::Result;

use radicle::node::notifications::Notification;

use radicle::storage::git::Repository;

use radicle::Profile;

#[derive(Clone, Default, Debug, Eq, PartialEq)]

pub struct Filter {}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]

pub struct SortBy {

    pub reverse: bool,

    pub field: &'static str,

}

impl Default for SortBy {

    fn default() -> Self {

        Self {

            reverse: true,

            field: "timestamp",

        }

    }

}

pub fn all(repository: &Repository, profile: &Profile) -> Result<Vec<Notification>> {

    let all = profile

        .notifications_mut()?

        .by_repo(&repository.id, "timestamp")?

        .collect::<Vec<_>>();

    let mut notifications = vec![];

    for n in all {

        let n = n?;

        notifications.push(n);

    }

    Ok(notifications)

}

use anyhow::Result;

use radicle::cob::issue::{Issue, IssueId};

use radicle::cob::Label;

use radicle::issue::cache::Issues;

use radicle::issue::State;

use radicle::prelude::{Did, Signer};

use radicle::storage::git::Repository;

use radicle::Profile;

#[derive(Clone, Debug, Eq, PartialEq)]

pub struct Filter {

    state: Option<State>,

    assigned: bool,

    assignees: Vec<Did>,

}

impl Default for Filter {

    fn default() -> Self {

        Self {

            state: Some(State::default()),

            assigned: false,

            assignees: vec![],

        }

    }

}

impl Filter {

    pub fn with_state(mut self, state: Option<State>) -> Self {

        self.state = state;

        self

    }

    pub fn with_assgined(mut self, assigned: bool) -> Self {

        self.assigned = assigned;

        self

    }

    pub fn with_assginee(mut self, assignee: Did) -> Self {

        self.assignees.push(assignee);

        self

    }

}

impl ToString for Filter {

    fn to_string(&self) -> String {

        let mut filter = String::new();

        if let Some(state) = &self.state {

            filter.push_str(&format!("is:{}", state));

            filter.push(' ');

        }

        if self.assigned {

            filter.push_str("is:assigned");

            filter.push(' ');

        }

        if !self.assignees.is_empty() {

            filter.push_str("assignees:");

            filter.push('[');

            let mut assignees = self.assignees.iter().peekable();

            while let Some(assignee) = assignees.next() {

                filter.push_str(&assignee.encode());

                if assignees.peek().is_some() {

                    filter.push(',');

                }

            }

            filter.push(']');

        }

        filter

    }

}

pub fn all(profile: &Profile, repository: &Repository) -> Result<Vec<(IssueId, Issue)>> {

    let cache = profile.issues(repository)?;

    let issues = cache.list()?;

    Ok(issues.flatten().collect())

}

pub fn find(profile: &Profile, repository: &Repository, id: &IssueId) -> Result<Option<Issue>> {

    let cache = profile.issues(repository)?;

    Ok(cache.get(id)?)

}

pub fn create<G: Signer>(

    profile: &Profile,

    repository: &Repository,

    signer: &G,

    title: String,

    description: String,

    labels: &[Label],

    assignees: &[Did],

) -> Result<IssueId> {

    let mut issues = profile.issues_mut(repository)?;

    let issue = issues.create(title, description.trim(), labels, assignees, [], signer)?;

    Ok(*issue.id())

}

#[cfg(test)]

mod tests {

    use std::str::FromStr;

    use anyhow::Result;

    use radicle::issue;

    use super::*;

    #[test]

    fn issue_filter_display_with_state_should_succeed() -> Result<()> {

        let actual = Filter::default().with_state(Some(issue::State::Open));

        assert_eq!(String::from("is:open "), actual.to_string());

        Ok(())

    }

    #[test]

    fn issue_filter_display_with_state_and_assigned_should_succeed() -> Result<()> {

        let actual = Filter::default()

            .with_state(Some(issue::State::Open))

            .with_assgined(true);

        assert_eq!(String::from("is:open is:assigned "), actual.to_string());

        Ok(())

    }

    #[test]

    fn issue_filter_display_with_status_and_author_should_succeed() -> Result<()> {

        let actual = Filter::default()

            .with_state(Some(issue::State::Open))

            .with_assginee(Did::from_str(

                "did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V",

            )?);

        assert_eq!(

            String::from(

                "is:open assignees:[did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V]"

            ),

            actual.to_string()

        );

        Ok(())

    }

}

use anyhow::Result;

use radicle::cob::patch::{Patch, PatchId};

use radicle::identity::Did;

use radicle::patch::cache::Patches;

use radicle::patch::Status;

use radicle::storage::git::Repository;

use radicle::Profile;

#[derive(Clone, Debug, Eq, PartialEq)]

pub struct Filter {

    status: Option<Status>,

    authored: bool,

    authors: Vec<Did>,

}

impl Default for Filter {

    fn default() -> Self {

        Self {

            status: Some(Status::default()),

            authored: false,

            authors: vec![],

        }

    }

}

impl Filter {

    pub fn with_status(mut self, status: Option<Status>) -> Self {

        self.status = status;

        self

    }

    pub fn with_authored(mut self, authored: bool) -> Self {

        self.authored = authored;

        self

    }

    pub fn with_author(mut self, author: Did) -> Self {

        self.authors.push(author);

        self

    }

}

impl ToString for Filter {

    fn to_string(&self) -> String {

        let mut filter = String::new();

        if let Some(state) = &self.status {

            filter.push_str(&format!("is:{}", state));

            filter.push(' ');

        }

        if self.authored {

            filter.push_str("is:authored");

            filter.push(' ');

        }

        if !self.authors.is_empty() {

            filter.push_str("authors:");

            filter.push('[');

            let mut authors = self.authors.iter().peekable();

            while let Some(author) = authors.next() {

                filter.push_str(&author.encode());

                if authors.peek().is_some() {

                    filter.push(',');

                }

            }

            filter.push(']');

        }

        filter

    }

}

pub fn all(profile: &Profile, repository: &Repository) -> Result<Vec<(PatchId, Patch)>> {

    let cache = profile.patches(repository)?;

    let patches = cache.list()?;

    Ok(patches.flatten().collect())

}

pub fn find(profile: &Profile, repository: &Repository, id: &PatchId) -> Result<Option<Patch>> {

    let cache = profile.patches(repository)?;

    Ok(cache.get(id)?)

}

#[cfg(test)]

mod tests {

    use std::str::FromStr;

    use anyhow::Result;

    use radicle::patch;

    use super::*;

    #[test]

    fn patch_filter_display_with_status_should_succeed() -> Result<()> {

        let actual = Filter::default().with_status(Some(patch::Status::Open));

        assert_eq!(String::from("is:open "), actual.to_string());

        Ok(())

    }

    #[test]

    fn patch_filter_display_with_status_and_authored_should_succeed() -> Result<()> {

        let actual = Filter::default()

            .with_status(Some(patch::Status::Open))

            .with_authored(true);

        assert_eq!(String::from("is:open is:authored "), actual.to_string());

        Ok(())

    }

    #[test]

    fn patch_filter_display_with_status_and_author_should_succeed() -> Result<()> {

        let actual = Filter::default()

            .with_status(Some(patch::Status::Open))

            .with_author(Did::from_str(

                "did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V",

            )?);

        assert_eq!(

            String::from(

                "is:open authors:[did:key:z6MkswQE8gwZw924amKatxnNCXA55BMupMmRg7LvJuim2C1V]"

            ),

            actual.to_string()

        );

        Ok(())

    }

}

use std::fmt::Display;

use radicle::cob::issue::{Issue, IssueId};

use radicle::cob::patch::{Patch, PatchId};

use radicle::crypto::ssh::keystore::{Keystore, MemorySigner};

use radicle::crypto::Signer;

use radicle::identity::{Project, RepoId};

use radicle::node::notifications::Notification;

use radicle::profile::env::RAD_PASSPHRASE;

use radicle::storage::git::Repository;

use radicle::storage::{ReadRepository, ReadStorage};

use radicle::Profile;

use radicle_term as term;

use term::{passphrase, spinner, Passphrase};

use inquire::validator;

use super::cob::inbox;

/// Git revision parameter. Supports extended SHA-1 syntax.

#[derive(Debug, Clone, PartialEq, Eq)]

pub struct Rev(String);

impl From<String> for Rev {

    fn from(value: String) -> Self {

        Rev(value)

    }

}

impl Display for Rev {

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

        write!(f, "{}", self.0)

    }

}

/// Application context that holds all the project data that are

/// needed to render it.

pub struct Context {

    profile: Profile,

    rid: RepoId,

    project: Project,

    repository: Repository,

    issues: Option<Vec<(IssueId, Issue)>>,

    patches: Option<Vec<(PatchId, Patch)>>,

    notifications: Vec<Notification>,

    signer: Option<Box<dyn Signer>>,

}

impl Context {

    pub fn new(profile: Profile, rid: RepoId) -> Result<Self, anyhow::Error> {

        let repository = profile.storage.repository(rid).unwrap();

        let project = repository.identity_doc()?.project()?;

        let notifications = inbox::all(&repository, &profile)?;

        let issues = None;

        let patches = None;

        let signer = None;

        Ok(Self {

            profile,

            rid,

            project,

            repository,

            issues,

            patches,

            notifications,

            signer,

        })

    }

    pub fn with_issues(mut self) -> Self {

        use super::cob::issue;

        self.issues = Some(issue::all(&self.profile, &self.repository).unwrap_or_default());

        self

    }

    pub fn with_patches(mut self) -> Self {

        use super::cob::patch;

        self.patches = Some(patch::all(&self.profile, &self.repository).unwrap_or_default());

        self

    }

    pub fn with_signer(mut self) -> Self {

        self.signer = signer(&self.profile).ok();

        self

    }

    pub fn profile(&self) -> &Profile {

        &self.profile

    }

    pub fn rid(&self) -> &RepoId {

        &self.rid

    }

    pub fn project(&self) -> &Project {

        &self.project

    }

    pub fn repository(&self) -> &Repository {

        &self.repository

    }

    pub fn issues(&self) -> &Option<Vec<(IssueId, Issue)>> {

        &self.issues

    }

    pub fn patches(&self) -> &Option<Vec<(PatchId, Patch)>> {

        &self.patches

    }

    pub fn notifications(&self) -> &Vec<Notification> {

        &self.notifications

    }

    #[allow(clippy::borrowed_box)]

    pub fn signer(&self) -> &Option<Box<dyn Signer>> {

        &self.signer

    }

    pub fn reload_patches(&mut self) {

        use super::cob::patch;

        self.patches = Some(patch::all(&self.profile, &self.repository).unwrap_or_default());

    }

    pub fn reload_issues(&mut self) {

        use super::cob::issue;

        self.issues = Some(issue::all(&self.profile, &self.repository).unwrap_or_default());

    }

}

/// Validates secret key passphrases.

#[derive(Clone)]

pub struct PassphraseValidator {

    keystore: Keystore,

}

impl PassphraseValidator {

    /// Create a new validator.

    pub fn new(keystore: Keystore) -> Self {

        Self { keystore }

    }

}

impl inquire::validator::StringValidator for PassphraseValidator {

    fn validate(

        &self,

        input: &str,

    ) -> Result<validator::Validation, inquire::error::CustomUserError> {

        let passphrase = Passphrase::from(input.to_owned());

        if self.keystore.is_valid_passphrase(&passphrase)? {

            Ok(validator::Validation::Valid)

        } else {

            Ok(validator::Validation::Invalid(

                validator::ErrorMessage::from("Invalid passphrase, please try again"),

            ))

        }

    }

}

/// Get the signer. First we try getting it from ssh-agent, otherwise we prompt the user,

/// if we're connected to a TTY.

pub fn signer(profile: &Profile) -> anyhow::Result<Box<dyn Signer>> {

    if let Ok(signer) = profile.signer() {

        return Ok(signer);

    }

    let validator = PassphraseValidator::new(profile.keystore.clone());

    let passphrase = match passphrase(validator) {

        Ok(p) => p,

        Err(inquire::InquireError::NotTTY) => {

            return Err(anyhow::anyhow!(

                "running in non-interactive mode, please set `{RAD_PASSPHRASE}` to unseal your key",

            ));

        }

        Err(e) => return Err(e.into()),

    };

    let spinner = spinner("Unsealing key...");

    let signer = MemorySigner::load(&profile.keystore, Some(passphrase))?;

    spinner.finish();

    Ok(signer.boxed())

}

use log::LevelFilter;

use radicle::profile::Profile;

pub fn enable(profile: &Profile, cmd: &str, op: &str) -> Result<(), anyhow::Error> {

    let logfile = format!(

        "{}/rad-tui-{}-{}.log",

        profile.home().path().to_string_lossy(),

        cmd,

        op,

    );

    simple_logging::log_to_file(logfile, LevelFilter::Info)?;

    Ok(())

}

pub mod event;

pub mod git;

pub mod store;

pub mod task;

pub mod terminal;

pub mod ui;

#[derive(Clone, Copy)]

pub enum Event {

    Key(termion::event::Key),

    Resize,

}

use radicle::git;

use radicle::git::Oid;

/// Get the diff stats between two commits.

/// Should match the default output of `git diff <old> <new> --stat` exactly.

pub fn diff_stats(

    repo: &git::raw::Repository,

    old: &Oid,

    new: &Oid,

) -> Result<git::raw::DiffStats, git::raw::Error> {

    let old = repo.find_commit(**old)?;

    let new = repo.find_commit(**new)?;

    let old_tree = old.tree()?;

    let new_tree = new.tree()?;

    let mut diff = repo.diff_tree_to_tree(Some(&old_tree), Some(&new_tree), None)?;

    let mut find_opts = git::raw::DiffFindOptions::new();

    diff.find_similar(Some(&mut find_opts))?;

    diff.stats()

}

use std::fmt::Debug;

use std::marker::PhantomData;

use std::time::Duration;

use tokio::sync::broadcast;

use tokio::sync::mpsc::{self, UnboundedReceiver, UnboundedSender};

use crate::Exit;

use super::task::{Interrupted, Terminator};

const STORE_TICK_RATE: Duration = Duration::from_millis(1000);

pub trait State<A, P>

where

    P: Clone + Debug + Send + Sync,

{

    fn tick(&self);

    fn handle_action(&mut self, action: A) -> Option<Exit<P>>;

}

pub struct Store<A, S, P>

where

    S: State<A, P> + Clone + Send + Sync,

    P: Clone + Debug + Send + Sync,

{

    state_tx: UnboundedSender<S>,

    _phantom: PhantomData<(A, P)>,

}

impl<A, S, P> Store<A, S, P>

where

    S: State<A, P> + Clone + Send + Sync,

    P: Clone + Debug + Send + Sync,

{

    pub fn new() -> (Self, UnboundedReceiver<S>) {

        let (state_tx, state_rx) = mpsc::unbounded_channel::<S>();

        (

            Store {

                state_tx,

                _phantom: PhantomData,

            },

            state_rx,

        )

    }

}

impl<A, S, P> Store<A, S, P>

where

    S: State<A, P> + Clone + Debug + Send + Sync + 'static,

    P: Clone + Debug + Send + Sync + 'static,

{

    pub async fn main_loop(

        self,

        mut state: S,

        mut terminator: Terminator<P>,

        mut action_rx: UnboundedReceiver<A>,

        mut interrupt_rx: broadcast::Receiver<Interrupted<P>>,

    ) -> anyhow::Result<Interrupted<P>> {

        // the initial state once

        self.state_tx.send(state.clone())?;

        let mut ticker = tokio::time::interval(STORE_TICK_RATE);

        let result = loop {

            tokio::select! {

                // Handle the actions coming from the UI

                // and process them to do async operations

                Some(action) = action_rx.recv() => {

                    if let Some(exit) = state.handle_action(action) {

                        let interrupted = Interrupted::User { payload: exit.value };

                        let _ = terminator.terminate(interrupted.clone());

                        break interrupted;

                    }

                },

                // Tick to terminate the select every N milliseconds

                _ = ticker.tick() => {

                    state.tick();

                },

                // Catch and handle interrupt signal to gracefully shutdown

                Ok(interrupted) = interrupt_rx.recv() => {

                    break interrupted;

                }

            }

            self.state_tx.send(state.clone())?;

        };

        Ok(result)

    }

}

/// A `StateValue` that writes updates to an internal

/// buffer. This buffer can be applied or reset.

///

/// Reading from a `StateValue` will return the buffer if it's

/// not empty. It will return the actual value otherwise.

#[derive(Clone, Debug)]

pub struct StateValue<T>

where

    T: Clone,

{

    value: T,

    buffer: Option<T>,

}

impl<T> StateValue<T>

where

    T: Clone,

{

    pub fn new(value: T) -> Self {

        Self {

            value,

            buffer: None,

        }

    }

    pub fn apply(&mut self) {

        if let Some(buffer) = self.buffer.clone() {

            self.value = buffer;

        }

        self.buffer = None;

    }

    pub fn reset(&mut self) {

        self.buffer = None;

    }

    pub fn write(&mut self, value: T) {

        self.buffer = Some(value);

    }

    pub fn read(&self) -> T {

        if let Some(buffer) = self.buffer.clone() {

            buffer

        } else {