version = "0.7.6"

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

checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"

dependencies = [

 "getrandom 0.2.10",

 "once_cell",

 "version_check",

]

[[package]]

name = "ahash"

name = "cassowary"

version = "0.3.0"

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

checksum = "df8670b8c7b9dae1793364eafadf7239c40d669904660c5960d74cfd80b46a53"

[[package]]

dependencies = [

 "ahash 0.7.6",

]

 "ahash 0.8.3",

name = "isolang"

version = "2.3.0"

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

checksum = "f80f221db1bc708b71128757b9396727c04de86968081e18e89b0575e03be071"

dependencies = [

 "phf",

]

[[package]]

name = "lazy-regex"

version = "2.5.0"

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

checksum = "ff63c423c68ea6814b7da9e88ce585f793c87ddd9e78f646970891769c8235d4"

dependencies = [

 "lazy-regex-proc_macros",

 "once_cell",

 "regex",

]

[[package]]

name = "lazy-regex-proc_macros"

version = "2.4.1"

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

checksum = "8edfc11b8f56ce85e207e62ea21557cfa09bb24a8f6b04ae181b086ff8611c22"

dependencies = [

 "proc-macro2",

 "quote",

 "regex",

 "syn 1.0.109",

]

[[package]]

name = "phf"

version = "0.11.2"

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

checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"

dependencies = [

 "phf_shared",

]

[[package]]

name = "phf_shared"

version = "0.11.2"

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

checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"

dependencies = [

 "siphasher",

]

[[package]]

 "timeago 0.3.1",

name = "radicle-tui"

version = "0.1.0"

dependencies = [

 "anyhow",

 "lexopt",

 "radicle",

 "radicle-cli",

 "radicle-surf",

 "radicle-term",

 "timeago 0.4.1",

 "tui-realm-stdlib",

 "tuirealm",

]

[[package]]

name = "smawk"

version = "0.3.1"

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

checksum = "f67ad224767faa3c7d8b6d91985b78e70a1324408abcb1cfcc2be4c06bc06043"

[[package]]

name = "textwrap"

version = "0.15.2"

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

checksum = "b7b3e525a49ec206798b40326a44121291b530c963cfb01018f63e135bac543d"

dependencies = [

 "smawk",

 "unicode-linebreak",

 "unicode-width",

]

[[package]]

name = "timeago"

version = "0.4.1"

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

checksum = "5082dc942361cdfb74eab98bf995762d6015e5bb3a20bf7c5c71213778b4fcb4"

dependencies = [

 "chrono",

 "isolang",

]

[[package]]

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.2.0"

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

checksum = "66f252bf8b07c6fd708ddd6349b5f044ae5b488b26929c745728d9c7e2cebfa6"

dependencies = [

 "textwrap",

 "tuirealm",

 "unicode-width",

]

[[package]]

name = "tuirealm"

version = "1.8.0"

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

checksum = "265411b5606f400459af94fbc5aae6a7bc0e98094d08cb5868390c932be88e26"

dependencies = [

 "bitflags 1.3.2",

 "lazy-regex",

 "termion 1.5.6",

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

name = "unicode-linebreak"

version = "0.1.4"

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

checksum = "c5faade31a542b8b35855fff6e8def199853b2da8da256da52f52f1316ee3137"

dependencies = [

 "hashbrown 0.12.3",

 "regex",

]

[[package]]

  "radicle-tui",

[package]

name = "radicle-tui"

license = "MIT OR Apache-2.0"

version = "0.1.0"

authors = ["Erik Kundt <erik@zirkular.io>"]

edition = "2021"

build = "../build.rs"

[[bin]]

name = "radicle-tui"

path = "src/main.rs"

[dependencies]

anyhow = { version = "1" }

lexopt = { version = "0.2" }

radicle-surf = { version = "0.14.0" }

timeago = { version = "0.4.1" }

tuirealm = { version = "1.8.0", default-features = false, features = [ "with-termion" ] }

tui-realm-stdlib = { version = "1.2.0", default-features = false, features = [ "with-termion" ] }

[dependencies.radicle]

version = "0"

path = "../radicle"

[dependencies.radicle-cli]

version = "0"

path = "../radicle-cli"

[dependencies.radicle-term]

version = "0"

path = "../radicle-term"

pub mod event;

pub mod page;

pub mod subscription;

use anyhow::Result;

use radicle::cob::issue::IssueId;

use radicle::cob::patch::PatchId;

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

use radicle::profile::Profile;

use tuirealm::application::PollStrategy;

use tuirealm::{Application, Frame, NoUserEvent};

use radicle_tui::ui::context::Context;

use radicle_tui::ui::theme::{self, Theme};

use radicle_tui::Tui;

use radicle_tui::{cob, ui};

use page::{HomeView, PatchView};

use self::page::{IssuePage, PageStack};

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

pub enum HomeCid {

    Header,

    Dashboard,

    IssueBrowser,

    PatchBrowser,

}

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

pub enum PatchCid {

    Header,

    Activity,

    Files,

}

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

pub enum IssueCid {

    Header,

    List,

    Details,

    Shortcuts,

}

/// All component ids known to this application.

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

pub enum Cid {

    Home(HomeCid),

    Issue(IssueCid),

    Patch(PatchCid),

    GlobalListener,

}

/// Messages handled by this application.

#[derive(Debug, Eq, PartialEq)]

pub enum HomeMessage {}

#[derive(Debug, Eq, PartialEq)]

pub enum IssueMessage {

    Show(IssueId),

    Changed(IssueId),

    Focus(IssueCid),

    Leave,

}

#[derive(Debug, Eq, PartialEq)]

pub enum PatchMessage {

    Show(PatchId),

    Leave,

}

#[derive(Debug, Eq, PartialEq)]

pub enum Message {

    Home(HomeMessage),

    Issue(IssueMessage),

    Patch(PatchMessage),

    NavigationChanged(u16),

    Tick,

    Quit,

}

#[allow(dead_code)]

pub struct App {

    context: Context,

    pages: PageStack,

    theme: Theme,

    quit: bool,

}

/// Creates a new application using a tui-realm-application, mounts all

/// components and sets focus to a default one.

impl App {

    pub fn new(profile: Profile, id: Id, project: Project) -> Self {

        Self {

            context: Context::new(profile, id, project),

            pages: PageStack::default(),

            theme: theme::default_dark(),

            quit: false,

        }

    }

    fn view_home(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        theme: &Theme,

    ) -> Result<()> {

        let home = Box::<HomeView>::default();

        self.pages.push(home, app, &self.context, theme)?;

        Ok(())

    }

    fn view_patch(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        id: PatchId,

        theme: &Theme,

    ) -> Result<()> {

        let repo = self.context.repository();

        if let Some(patch) = cob::patch::find(repo, &id)? {

            let view = Box::new(PatchView::new((id, patch)));

            self.pages.push(view, app, &self.context, theme)?;

            Ok(())

        } else {

            Err(anyhow::anyhow!(

                "Could not mount 'page::PatchView'. Patch not found."

            ))

        }

    }

    fn view_issue(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        id: IssueId,

        theme: &Theme,

    ) -> Result<()> {

        let repo = self.context.repository();

        if let Some(issue) = cob::issue::find(repo, &id)? {

            let view = Box::new(IssuePage::new((id, issue)));

            self.pages.push(view, app, &self.context, theme)?;

            Ok(())

        } else {

            Err(anyhow::anyhow!(

                "Could not mount 'page::IssueView'. Issue not found."

            ))

        }

    }

}

impl Tui<Cid, Message> for App {

    fn init(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        self.view_home(app, &self.theme.clone())?;

        // Add global key listener and subscribe to key events

        let global = ui::widget::common::global_listener().to_boxed();

        app.mount(Cid::GlobalListener, global, subscription::global())?;

        Ok(())

    }

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {

        if let Ok(page) = self.pages.peek_mut() {

            page.view(app, frame);

        }

    }

    fn update(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<bool> {

        match app.tick(PollStrategy::Once) {

            Ok(messages) if !messages.is_empty() => {

                let theme = theme::default_dark();

                for message in messages {

                    match message {

                        Message::Issue(IssueMessage::Show(id)) => {

                            self.view_issue(app, id, &theme)?;

                        }

                        Message::Issue(IssueMessage::Leave) => {

                            self.pages.pop(app)?;

                        }

                        Message::Patch(PatchMessage::Show(id)) => {

                            self.view_patch(app, id, &theme)?;

                        }

                        Message::Patch(PatchMessage::Leave) => {

                            self.pages.pop(app)?;

                        }

                        Message::Quit => self.quit = true,

                        _ => {

                            self.pages

                                .peek_mut()?

                                .update(app, &self.context, &theme, message)?;

                        }

                    }

                }

                Ok(true)

            }

            _ => Ok(false),

        }

    }

    fn quit(&self) -> bool {

        self.quit

    }

}

use tuirealm::command::{Cmd, CmdResult, Direction as MoveDirection};

use tuirealm::event::{Event, Key, KeyEvent};

use tuirealm::{MockComponent, NoUserEvent, State, StateValue};

use radicle_tui::ui::widget::common::container::{AppHeader, GlobalListener, LabeledContainer};

use radicle_tui::ui::widget::common::context::{ContextBar, Shortcuts};

use radicle_tui::ui::widget::common::list::PropertyList;

use radicle_tui::ui::widget::home::{Dashboard, IssueBrowser, PatchBrowser};

use radicle_tui::ui::widget::{issue, patch};

use radicle_tui::ui::widget::Widget;

use super::{IssueMessage, Message, PatchMessage};

/// Since the framework does not know the type of messages that are being

/// passed around in the app, the following handlers need to be implemented for

/// each component used.

///

/// TODO: should handle `Event::WindowResize`, which is not emitted by `termion`.

impl tuirealm::Component<Message, NoUserEvent> for Widget<GlobalListener> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent {

                code: Key::Char('q'),

                ..

            }) => Some(Message::Quit),

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<AppHeader> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Tab, .. }) => {

                match self.perform(Cmd::Move(MoveDirection::Right)) {

                    CmdResult::Changed(State::One(StateValue::U16(index))) => {

                        Some(Message::NavigationChanged(index))

                    }

                    _ => None,

                }

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<issue::LargeList> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {

                Some(Message::Issue(IssueMessage::Leave))

            }

            Event::Keyboard(KeyEvent { code: Key::Up, .. }) => {

                let result = self.perform(Cmd::Move(MoveDirection::Up));

                match result {

                    CmdResult::Changed(State::One(StateValue::Usize(selected))) => {

                        let item = self.items().get(selected)?;

                        Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))

                    }

                    _ => None,

                }

            }

            Event::Keyboard(KeyEvent {

                code: Key::Down, ..

            }) => {

                let result = self.perform(Cmd::Move(MoveDirection::Down));

                match result {

                    CmdResult::Changed(State::One(StateValue::Usize(selected))) => {

                        let item = self.items().get(selected)?;

                        Some(Message::Issue(IssueMessage::Changed(item.id().to_owned())))

                    }

                    _ => None,

                }

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<issue::Details> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<PatchBrowser> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Up, .. }) => {

                self.perform(Cmd::Move(MoveDirection::Up));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Down, ..

            }) => {

                self.perform(Cmd::Move(MoveDirection::Down));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Enter, ..

            }) => {

                let result = self.perform(Cmd::Submit);

                match result {

                    CmdResult::Submit(State::One(StateValue::Usize(selected))) => {

                        let item = self.items().get(selected)?;

                        Some(Message::Patch(PatchMessage::Show(item.id().to_owned())))

                    }

                    _ => None,

                }

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<IssueBrowser> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Up, .. }) => {

                self.perform(Cmd::Move(MoveDirection::Up));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Down, ..

            }) => {

                self.perform(Cmd::Move(MoveDirection::Down));

                Some(Message::Tick)

            }

            Event::Keyboard(KeyEvent {

                code: Key::Enter, ..

            }) => {

                let result = self.perform(Cmd::Submit);

                match result {

                    CmdResult::Submit(State::One(StateValue::Usize(selected))) => {

                        let item = self.items().get(selected)?;

                        Some(Message::Issue(IssueMessage::Show(item.id().to_owned())))

                    }

                    _ => None,

                }

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<Dashboard> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<patch::Activity> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {

                Some(Message::Patch(PatchMessage::Leave))

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<patch::Files> {

    fn on(&mut self, event: Event<NoUserEvent>) -> Option<Message> {

        match event {

            Event::Keyboard(KeyEvent { code: Key::Esc, .. }) => {

                Some(Message::Patch(PatchMessage::Leave))

            }

            _ => None,

        }

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<LabeledContainer> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<PropertyList> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<ContextBar> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

impl tuirealm::Component<Message, NoUserEvent> for Widget<Shortcuts> {

    fn on(&mut self, _event: Event<NoUserEvent>) -> Option<Message> {

        None

    }

}

use anyhow::Result;

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

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

use radicle_tui::cob;

use tuirealm::{Frame, NoUserEvent, Sub, SubClause};

use radicle_tui::ui::context::Context;

use radicle_tui::ui::layout;

use radicle_tui::ui::theme::Theme;

use radicle_tui::ui::widget;

use super::{subscription, Application, Cid, HomeCid, IssueCid, IssueMessage, Message, PatchCid};

/// `tuirealm`'s event and prop system is designed to work with flat component hierarchies.

/// Building deep nested component hierarchies would need a lot more additional effort to

/// properly pass events and props down these hierarchies. This makes it hard to implement

/// full app views (home, patch details etc) as components.

///

/// View pages take into account these flat component hierarchies, and provide

/// switchable sets of components.

pub trait ViewPage {

    /// Will be called whenever a view page is pushed onto the page stack. Should create and mount all widgets.

    fn mount(

        &self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

    ) -> Result<()>;

    /// Will be called whenever a view page is popped from the page stack. Should unmount all widgets.

    fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()>;

    /// Will be called whenever a view page is on top of the stack and can be used to update its internal

    /// state depending on the message passed.

    fn update(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

        message: Message,

    ) -> Result<()>;

    /// Will be called whenever a view page is on top of the page stack and needs to be rendered.

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame);

    /// Will be called whenever this view page is pushed to the stack, or it is on top of the stack again

    /// after another view page was popped from the stack.

    fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()>;

    /// Will be called whenever this view page is on top of the stack and another view page is pushed

    /// to the stack, or if this is popped from the stack.

    fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()>;

}

///

/// Home

///

pub struct HomeView {

    active_component: Cid,

}

impl Default for HomeView {

    fn default() -> Self {

        HomeView {

            active_component: Cid::Home(HomeCid::Dashboard),

        }

    }

}

impl ViewPage for HomeView {

    fn mount(

        &self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

    ) -> Result<()> {

        let navigation = widget::home::navigation(theme);

        let header = widget::common::app_header(context, theme, Some(navigation)).to_boxed();

        let dashboard = widget::home::dashboard(context, theme).to_boxed();

        let issue_browser = widget::home::issues(context, theme).to_boxed();

        let patch_browser = widget::home::patches(context, theme).to_boxed();

        app.remount(Cid::Home(HomeCid::Header), header, vec![])?;

        app.remount(Cid::Home(HomeCid::Dashboard), dashboard, vec![])?;

        app.remount(Cid::Home(HomeCid::IssueBrowser), issue_browser, vec![])?;

        app.remount(Cid::Home(HomeCid::PatchBrowser), patch_browser, vec![])?;

        app.active(&self.active_component)?;

        Ok(())

    }

    fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.umount(&Cid::Home(HomeCid::Header))?;

        app.umount(&Cid::Home(HomeCid::Dashboard))?;

        app.umount(&Cid::Home(HomeCid::IssueBrowser))?;

        app.umount(&Cid::Home(HomeCid::PatchBrowser))?;

        Ok(())

    }

    fn update(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        _context: &Context,

        _theme: &Theme,

        message: Message,

    ) -> Result<()> {

        if let Message::NavigationChanged(index) = message {

            self.active_component = Cid::Home(HomeCid::from(index as usize));

            app.active(&self.active_component)?;

        }

        Ok(())

    }

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {

        let area = frame.size();

        let layout = layout::default_page(area);

        app.view(&Cid::Home(HomeCid::Header), frame, layout[0]);

        app.view(&self.active_component, frame, layout[1]);

    }

    fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.subscribe(

            &Cid::Home(HomeCid::Header),

            Sub::new(subscription::navigation_clause(), SubClause::Always),

        )?;

        Ok(())

    }

    fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.unsubscribe(

            &Cid::Home(HomeCid::Header),

            subscription::navigation_clause(),

        )?;

        Ok(())

    }

}

///

/// Issue detail page

///

pub struct IssuePage {

    issue: (IssueId, Issue),

}

impl IssuePage {

    pub fn new(issue: (IssueId, Issue)) -> Self {

        IssuePage { issue }

    }

}

impl ViewPage for IssuePage {

    fn mount(

        &self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

    ) -> Result<()> {

        let (id, issue) = &self.issue;

        let header = widget::common::app_header(context, theme, None).to_boxed();

        let list = widget::issue::list(context, theme, (*id, issue.clone())).to_boxed();

        let details = widget::issue::details(context, theme, (*id, issue.clone())).to_boxed();

        let shortcuts = widget::common::shortcuts(

            theme,

            vec![

                widget::common::shortcut(theme, "esc", "back"),

                widget::common::shortcut(theme, "q", "quit"),

            ],

        )

        .to_boxed();

        app.remount(Cid::Issue(IssueCid::Header), header, vec![])?;

        app.remount(Cid::Issue(IssueCid::List), list, vec![])?;

        app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;

        app.remount(Cid::Issue(IssueCid::Shortcuts), shortcuts, vec![])?;

        app.active(&Cid::Issue(IssueCid::List))?;

        Ok(())

    }

    fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.umount(&Cid::Issue(IssueCid::Header))?;

        app.umount(&Cid::Issue(IssueCid::List))?;

        app.umount(&Cid::Issue(IssueCid::Details))?;

        app.umount(&Cid::Issue(IssueCid::Shortcuts))?;

        Ok(())

    }

    fn update(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

        message: Message,

    ) -> Result<()> {

        match message {

            Message::Issue(IssueMessage::Changed(id)) => {

                let repo = context.repository();

                if let Some(issue) = cob::issue::find(repo, &id)? {

                    let details = widget::issue::details(context, theme, (id, issue)).to_boxed();

                    app.remount(Cid::Issue(IssueCid::Details), details, vec![])?;

                }

            }

            Message::Issue(IssueMessage::Focus(cid)) => {

                app.active(&Cid::Issue(cid))?;

            }

            _ => {}

        }

        Ok(())

    }

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {

        let area = frame.size();

        let shortcuts_h = 1u16;

        let layout = layout::issue_preview(area, shortcuts_h);

        app.view(&Cid::Issue(IssueCid::Header), frame, layout.header);

        app.view(&Cid::Issue(IssueCid::List), frame, layout.list);

        app.view(&Cid::Issue(IssueCid::Details), frame, layout.details);

        app.view(&Cid::Issue(IssueCid::Shortcuts), frame, layout.shortcuts);

    }

    fn subscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        Ok(())

    }

    fn unsubscribe(&self, _app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        Ok(())

    }

}

///

/// Patch detail page

///

pub struct PatchView {

    active_component: Cid,

    patch: (PatchId, Patch),

}

impl PatchView {

    pub fn new(patch: (PatchId, Patch)) -> Self {

        PatchView {

            active_component: Cid::Patch(PatchCid::Activity),

            patch,

        }

    }

}

impl ViewPage for PatchView {

    fn mount(

        &self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

    ) -> Result<()> {

        let (id, patch) = &self.patch;

        let navigation = widget::patch::navigation(theme);

        let header = widget::common::app_header(context, theme, Some(navigation)).to_boxed();

        let activity = widget::patch::activity(theme, (*id, patch), context.profile()).to_boxed();

        let files = widget::patch::files(theme, (*id, patch), context.profile()).to_boxed();

        app.remount(Cid::Patch(PatchCid::Header), header, vec![])?;

        app.remount(Cid::Patch(PatchCid::Activity), activity, vec![])?;

        app.remount(Cid::Patch(PatchCid::Files), files, vec![])?;

        app.active(&self.active_component)?;

        Ok(())

    }

    fn unmount(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.umount(&Cid::Patch(PatchCid::Header))?;

        app.umount(&Cid::Patch(PatchCid::Activity))?;

        app.umount(&Cid::Patch(PatchCid::Files))?;

        Ok(())

    }

    fn update(

        &mut self,

        app: &mut Application<Cid, Message, NoUserEvent>,

        _context: &Context,

        _theme: &Theme,

        message: Message,

    ) -> Result<()> {

        if let Message::NavigationChanged(index) = message {

            self.active_component = Cid::Patch(PatchCid::from(index as usize));

        }

        app.active(&self.active_component)?;

        Ok(())

    }

    fn view(&mut self, app: &mut Application<Cid, Message, NoUserEvent>, frame: &mut Frame) {

        let area = frame.size();

        let layout = layout::default_page(area);

        app.view(&Cid::Patch(PatchCid::Header), frame, layout[0]);

        app.view(&self.active_component, frame, layout[1]);

    }

    fn subscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.subscribe(

            &Cid::Patch(PatchCid::Header),

            Sub::new(subscription::navigation_clause(), SubClause::Always),

        )?;

        Ok(())

    }

    fn unsubscribe(&self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        app.unsubscribe(

            &Cid::Patch(PatchCid::Header),

            subscription::navigation_clause(),

        )?;

        Ok(())

    }

}

/// View pages need to preserve their state (e.g. selected navigation tab, contents

/// and the selected row of a table). Therefor they should not be (re-)created

/// each time they are displayed.

/// Instead the application can push a new page onto the page stack if it needs to

/// be displayed. Its components are then created using the internal state. If a

/// new page needs to be displayed, it will also be pushed onto the stack. Leaving

/// that page again will pop it from the stack. The application can then return to

/// the previously displayed page in the state it was left.

#[derive(Default)]

pub struct PageStack {

    pages: Vec<Box<dyn ViewPage>>,

}

impl PageStack {

    pub fn push(

        &mut self,

        page: Box<dyn ViewPage>,

        app: &mut Application<Cid, Message, NoUserEvent>,

        context: &Context,

        theme: &Theme,

    ) -> Result<()> {

        if let Some(page) = self.pages.last() {

            page.unsubscribe(app)?;

        }

        page.mount(app, context, theme)?;

        page.subscribe(app)?;

        self.pages.push(page);

        Ok(())

    }

    pub fn pop(&mut self, app: &mut Application<Cid, Message, NoUserEvent>) -> Result<()> {

        self.peek_mut()?.unsubscribe(app)?;

        self.peek_mut()?.unmount(app)?;

        self.pages.pop();

        self.peek_mut()?.subscribe(app)?;

        Ok(())

    }

    pub fn peek_mut(&mut self) -> Result<&mut Box<dyn ViewPage>> {

        match self.pages.last_mut() {

            Some(page) => Ok(page),

            None => Err(anyhow::anyhow!(

                "Could not peek active page. Page stack is empty."

            )),

        }

    }

}

impl From<usize> for HomeCid {

    fn from(index: usize) -> Self {

        match index {

            0 => HomeCid::Dashboard,

            1 => HomeCid::IssueBrowser,

            2 => HomeCid::PatchBrowser,

            _ => HomeCid::Dashboard,

        }

    }

}

impl From<usize> for PatchCid {

    fn from(index: usize) -> Self {

        match index {

            0 => PatchCid::Activity,

            1 => PatchCid::Files,

            _ => PatchCid::Activity,

        }

    }

}

use std::hash::Hash;

use tuirealm::event::{Key, KeyEvent, KeyModifiers};

use tuirealm::{Sub, SubClause, SubEventClause};

pub fn navigation_clause<UserEvent>() -> SubEventClause<UserEvent>

where

    UserEvent: Clone + Eq + PartialEq + PartialOrd,

{

    SubEventClause::Keyboard(KeyEvent {

        code: Key::Tab,

        modifiers: KeyModifiers::NONE,

    })

}

pub fn global<Id, UserEvent>() -> Vec<Sub<Id, UserEvent>>

where

    Id: Clone + Hash + Eq + PartialEq,

    UserEvent: Clone + Eq + PartialEq + PartialOrd,

{

    vec![

        Sub::new(

            SubEventClause::Keyboard(KeyEvent {

                code: Key::Char('q'),

                modifiers: KeyModifiers::NONE,

            }),

            SubClause::Always,

        ),

        Sub::new(SubEventClause::WindowResize, SubClause::Always),

    ]

}

pub mod issue;

pub mod patch;

use anyhow::Result;

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

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

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

    let patches = Issues::open(repository)?

        .all()

        .map(|iter| iter.flatten().collect::<Vec<_>>())?;

    Ok(patches

        .into_iter()

        .map(|(id, issue)| (id, issue))

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

}

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

    let issues = Issues::open(repository)?;

    Ok(issues.get(id)?)

}

use anyhow::Result;

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

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

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

    let patches = Patches::open(repository)?

        .all()

        .map(|iter| iter.flatten().collect::<Vec<_>>())?;

    Ok(patches

        .into_iter()

        .map(|(id, patch)| (id, patch))

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

}

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

    let patches = Patches::open(repository)?;

    Ok(patches.get(id)?)

}

use std::hash::Hash;

use std::time::Duration;

use anyhow::Result;

use tuirealm::terminal::TerminalBridge;

use tuirealm::tui::layout::Rect;

use tuirealm::Frame;

use tuirealm::{Application, EventListenerCfg, NoUserEvent};

pub mod cob;

pub mod ui;

/// Trait that must be implemented by client applications in order to be run

/// as tui-application using tui-realm. Implementors act as models to the

/// tui-realm application that can be polled for new messages, updated

/// accordingly and rendered with new state.

///

/// Please see `examples/` for further information on how to use it.

pub trait Tui<Id, Message>

where

    Id: Eq + PartialEq + Clone + Hash,

    Message: Eq,

{

    /// Should initialize an application by mounting and activating components.

    fn init(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<()>;

    /// Should update the current state by handling a message from the view. Returns true

    /// if view should be updated (e.g. a message was received and the current state changed).

    fn update(&mut self, app: &mut Application<Id, Message, NoUserEvent>) -> Result<bool>;

    /// Should draw the application to a frame.

    fn view(&mut self, app: &mut Application<Id, Message, NoUserEvent>, frame: &mut Frame);

    /// Should return true if the application is requested to quit.

    fn quit(&self) -> bool;

}

/// A tui-window using the cross-platform Terminal helper provided

/// by tui-realm.

pub struct Window {

    /// Helper around `Terminal` to quickly setup and perform on terminal.

    pub terminal: TerminalBridge,

}

impl Default for Window {

    fn default() -> Self {

        Self::new()

    }

}

/// Provides a way to create and run a new tui-application.

impl Window {

    /// Creates a tui-window using the default cross-platform Terminal

    /// helper and panics if its creation fails.

    pub fn new() -> Self {

        Self {

            terminal: TerminalBridge::new().expect("Cannot create terminal bridge"),

        }

    }

    /// Runs this tui-window with the tui-application given and performs the

    /// following steps:

    /// 1. Enter alternative terminal screen

    /// 2. Run main loop until application should quit and with each iteration

    ///    - poll new events (tick or user event)

    ///    - update application state

    ///    - redraw view

    /// 3. Leave alternative terminal screen

    pub fn run<T, Id, Message>(&mut self, tui: &mut T, interval: u64) -> Result<()>

    where

        T: Tui<Id, Message>,

        Id: Eq + PartialEq + Clone + Hash,

        Message: Eq,

    {

        let mut update = true;

        let mut resize = false;

        let mut size = Rect::default();

        let mut app = Application::init(

            EventListenerCfg::default().default_input_listener(Duration::from_millis(interval)),

        );

        tui.init(&mut app)?;

        while !tui.quit() {

            if update || resize {

                self.terminal

                    .raw_mut()

                    .draw(|frame| tui.view(&mut app, frame))?;

            }

            update = tui.update(&mut app)?;

            resize = size != self.terminal.raw().size()?;

            size = self.terminal.raw().size()?;

        }

        Ok(())

    }

}

use std::process;

use anyhow::{anyhow, Context};

use radicle::storage::ReadStorage;

use radicle_cli as cli;

use radicle_term as term;

use radicle_tui::Window;

mod app;

pub const NAME: &str = "radicle-tui";

pub const VERSION: &str = env!("CARGO_PKG_VERSION");

pub const GIT_HEAD: &str = env!("GIT_HEAD");

pub const FPS: u64 = 60;

pub const HELP: &str = r#"

Usage

    radicle-tui [<option>...]

Options

    --version       Print version

    --help          Print help

"#;

struct Options;

impl Options {

    fn from_env() -> Result<Self, anyhow::Error> {

        use lexopt::prelude::*;

        let mut parser = lexopt::Parser::from_env();

        while let Some(arg) = parser.next()? {

            match arg {

                Long("version") => {

                    println!("{NAME} {VERSION}+{GIT_HEAD}");

                    process::exit(0);

                }

                Long("help") | Short('h') => {

                    println!("{HELP}");

                    process::exit(0);

                }

                _ => anyhow::bail!(arg.unexpected()),

            }

        }

        Ok(Self {})

    }

}

fn execute() -> anyhow::Result<()> {

    let _ = Options::from_env()?;

    let (_, id) = radicle::rad::cwd()

        .map_err(|_| anyhow!("this command must be run in the context of a project"))?;

    let profile = cli::terminal::profile()?;

    let signer = cli::terminal::signer(&profile)?;

    let storage = &profile.storage;

    let payload = storage

        .get(signer.public_key(), id)?

        .context("No project with such `id` exists")?;

    let project = payload.project()?;

    let mut window = Window::default();

    window.run(&mut app::App::new(profile, id, project), 1000 / FPS)?;

    Ok(())

}

fn main() {

    if let Err(err) = execute() {

        term::error(format!("Error: rad-tui: {err}"));

        process::exit(1);

    }

}

pub mod cob;

pub mod context;

pub mod ext;

pub mod layout;

pub mod state;

pub mod theme;

pub mod widget;

use radicle_surf;

use cli::terminal::format;

use radicle_cli as cli;

use radicle::prelude::Did;

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

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

use radicle::Profile;

use radicle::cob::issue::{Issue, IssueId, State as IssueState};

use radicle::cob::patch::{Patch, PatchId, State as PatchState};

use radicle::cob::{Label, Timestamp};

use tuirealm::props::{Color, Style};

use tuirealm::tui::text::{Span, Spans};

use tuirealm::tui::widgets::Cell;

use crate::ui::theme::Theme;

use crate::ui::widget::common::list::TableItem;

use super::widget::common::list::ListItem;

/// An author item that can be used in tables, list or trees.

///

/// Breaks up dependencies to [`Profile`] and [`Repository`] that

/// would be needed if [`AuthorItem`] would be used directly.

#[derive(Clone)]

pub struct AuthorItem {

    /// The author's DID.

    did: Did,

    /// True if the author is the current user.

    is_you: bool,

}

impl AuthorItem {

    pub fn did(&self) -> Did {

        self.did

    }

    pub fn is_you(&self) -> bool {

        self.is_you

    }

}

/// A patch item that can be used in tables, list or trees.

///

/// Breaks up dependencies to [`Profile`] and [`Repository`] that

/// would be needed if [`Patch`] would be used directly.

#[derive(Clone)]

pub struct PatchItem {

    /// Patch OID.

    id: PatchId,

    /// Patch state.

    state: PatchState,

    /// Patch title.

    title: String,

    /// Author of the latest revision.

    author: AuthorItem,

    /// Head of the latest revision.

    head: Oid,

    /// Lines added by the latest revision.

    added: u16,

    /// Lines removed by the latest revision.

    removed: u16,

    /// Time when patch was opened.

    timestamp: Timestamp,

}

impl PatchItem {

    pub fn id(&self) -> &PatchId {

        &self.id

    }

    pub fn state(&self) -> &PatchState {

        &self.state

    }

    pub fn title(&self) -> &String {

        &self.title

    }

    pub fn author(&self) -> &AuthorItem {

        &self.author

    }

    pub fn head(&self) -> &Oid {

        &self.head

    }

    pub fn added(&self) -> u16 {

        self.added

    }

    pub fn removed(&self) -> u16 {

        self.removed

    }

    pub fn timestamp(&self) -> &Timestamp {

        &self.timestamp

    }

}

impl TryFrom<(&Profile, &Repository, PatchId, Patch)> for PatchItem {

    type Error = anyhow::Error;

    fn try_from(value: (&Profile, &Repository, PatchId, Patch)) -> Result<Self, Self::Error> {

        let (profile, repo, id, patch) = value;

        let (_, rev) = patch.latest();

        let repo = radicle_surf::Repository::open(repo.path())?;

        let base = repo.commit(rev.base())?;

        let head = repo.commit(rev.head())?;

        let diff = repo.diff(base.id, head.id)?;

        Ok(PatchItem {

            id,

            state: patch.state().clone(),

            title: patch.title().into(),

            author: AuthorItem {

                did: patch.author().id,

                is_you: *patch.author().id == *profile.did(),

            },

            head: rev.head(),

            added: diff.stats().insertions as u16,

            removed: diff.stats().deletions as u16,

            timestamp: rev.timestamp(),

        })

    }

}

impl TableItem<8> for PatchItem {

    fn row(&self, theme: &Theme) -> [Cell; 8] {

        let (icon, color) = format_patch_state(&self.state);

        let state = Cell::from(icon).style(Style::default().fg(color));

        let id = Cell::from(format::cob(&self.id))

            .style(Style::default().fg(theme.colors.browser_list_id));

        let title = Cell::from(self.title.clone())

            .style(Style::default().fg(theme.colors.browser_list_title));

        let author = Cell::from(format_author(&self.author.did, self.author.is_you))

            .style(Style::default().fg(theme.colors.browser_list_author));

        let head = Cell::from(format::oid(self.head).item)

            .style(Style::default().fg(theme.colors.browser_patch_list_head));

        let added = Cell::from(format!("{}", self.added))

            .style(Style::default().fg(theme.colors.browser_patch_list_added));

        let removed = Cell::from(format!("{}", self.removed))

            .style(Style::default().fg(theme.colors.browser_patch_list_removed));

        let updated = Cell::from(format::timestamp(&self.timestamp).to_string())

            .style(Style::default().fg(theme.colors.browser_list_timestamp));

        [state, id, title, author, head, added, removed, updated]

    }

}

/// An issue item that can be used in tables, list or trees.

///

/// Breaks up dependencies to [`Profile`] and [`Repository`] that

/// would be needed if [`Issue`] would be used directly.

#[derive(Clone)]

pub struct IssueItem {

    /// Issue OID.

    id: IssueId,

    /// Issue state.

    state: IssueState,

    /// Issue title.

    title: String,

    /// Issue author.

    author: AuthorItem,

    /// Issue labels.

    labels: Vec<Label>,

    /// Issue assignees.

    assignees: Vec<AuthorItem>,

    /// Time when issue was opened.

    timestamp: Timestamp,

}

impl IssueItem {

    pub fn id(&self) -> &IssueId {

        &self.id

    }

    pub fn state(&self) -> &IssueState {

        &self.state

    }

    pub fn title(&self) -> &String {