name = "dyn-clone"

version = "1.0.10"

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

checksum = "c9b0705efd4599c15a38151f4721f7bc388306f61084d3bfd50bd07fbca5cb60"

[[package]]

name = "inout"

version = "0.1.3"

checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5"

 "generic-array",

name = "inquire"

version = "0.5.3"

checksum = "f3a94f0659efe59329832ba0452d3ec753145fc1fb12a8e1d60de4ccf99f5364"

 "bitflags",

 "dyn-clone",

 "lazy_static",

 "newline-converter",

 "tempfile",

 "termion 1.5.6",

 "thiserror",

 "unicode-segmentation",

 "unicode-width",

name = "newline-converter"

version = "0.2.2"

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

checksum = "1f71d09d5c87634207f894c6b31b6a2b2c64ea3bdcf71bd5599fdbbe1600c00f"

dependencies = [

 "unicode-segmentation",

]

[[package]]

name = "numtoa"

version = "0.1.0"

checksum = "b8f8bdf33df195859076e54ab11ee78a1b208382d3a26ec40d142ffc1ecc49ef"

 "concolor",

 "inquire",

 "once_cell",

 "termion 2.0.1",

 "unicode-segmentation",

 "unicode-width",

 "radicle-cli",

name = "redox_termios"

version = "0.1.2"

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

checksum = "8440d8acb4fd3d277125b4bd01a6f38aee8d814b3b5fc09b3f2b825d37d3fe8f"

dependencies = [

 "redox_syscall",

]

[[package]]

name = "termion"

version = "1.5.6"

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

checksum = "077185e2eac69c3f8379a4298e1e07cd36beb962290d4a51199acf0fdc10607e"

dependencies = [

 "libc",

 "numtoa",

 "redox_syscall",

 "redox_termios",

]

[[package]]

name = "termion"

version = "2.0.1"

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

checksum = "659c1f379f3408c7e5e84c7d0da6d93404e3800b6b9d063ba24436419302ec90"

dependencies = [

 "libc",

 "numtoa",

 "redox_syscall",

 "redox_termios",

]

[[package]]

name = "unicode-segmentation"

version = "1.10.1"

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

checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"

[[package]]

const ERROR_PREFIX: &str = "✗";

concolor = { version = "0", features = ["api_unstable"] }

inquire = { version = "0.5.3", default-features = false, features = ["termion", "editor"] }

once_cell = { version = "1.13" }

termion = { version = "2" }

unicode-width = { version = "0.1.10", default-features = false }

unicode-segmentation = { version = "1.7.1" }

tempfile = { version = "3.3.0" }

✓ Creating your 🌱 Ed25519 keypair...

✓ Your Radicle ID is did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi. This identifies your device.

👉 To create a radicle project, run `rad init` from a git repository.

✓ Performing checkout...

✓ Tracking relationship established for rad:zVNuptPuk5XauitpCWSNVCXGGfXW

✗ Clone failed: no seeds found for rad:zVNuptPuk5XauitpCWSNVCXGGfXW

✓ Tracking relationship established for rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji

✓ Fetching rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from z6MknSL…StBU8Vi..

✓ Forking under z6Mkt67…v4N1tRk..

✓ Creating checkout in ./heartwood..

✓ Remote z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi created

✓ Remote-tracking branch z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/master created for z6MknSL…StBU8Vi

✓ Update successful!

✓ Update successful!

✓ Identity proposal '57332790a2eabc0b2fd8c7ff48c3579d5812d405' created 🌱

status: ❲open❳

👎 no

✓ Identity proposal 'c3698d4e85f9d4c0ee536b34d6122fc7c81f7e2e' created 🌱

status: ❲open❳

👎 no

✓ Accepted proposal ✓

status: ❲open❳

👍 yes

✓ Committed new identity '29ae4b72f5a315328f06fbd68dc1c396a2d5c45e' 🌱

status: ❲committed❳

👍 yes

! Warning: Revision is out of date

! Warning: d96f425412c9f8ad5d9a9a05c9831d0728e2338d =/= 475cdfbc8662853dd132ec564e4f5eb0f152dd7f

👉 Consider using 'rad id rebase' to update the proposal to the latest identity

✓ Accepted proposal ✓

status: ❲open❳

👍 yes

! Warning: Revision is out of date

! Warning: d96f425412c9f8ad5d9a9a05c9831d0728e2338d =/= 475cdfbc8662853dd132ec564e4f5eb0f152dd7f

👉 Consider using 'rad id rebase' to update the proposal to the latest identity

✗ Id failed: the identity hashes do match 'd96f425412c9f8ad5d9a9a05c9831d0728e2338d =/= 475cdfbc8662853dd132ec564e4f5eb0f152dd7f' for the revision 'z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/1'

✓ Identity proposal 'c3698d4e85f9d4c0ee536b34d6122fc7c81f7e2e' rebased 🌱

✓ Revision 'z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/4'

status: ❲open❳

👎 no

✓ Identity proposal 'c3698d4e85f9d4c0ee536b34d6122fc7c81f7e2e' updated 🌱

✓ Revision 'z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/6'

status: ❲open❳

👎 no

✓ Accepted proposal ✓

status: ❲open❳

👍 yes

✓ Committed new identity '60de897bc24898f6908fd1272633c0b15aa4096f' 🌱

status: ❲committed❳

👍 yes

✓ Identity proposal '06d9efa2a9aad06bfdf25a25690e1ec7db2c3c39' created 🌱

status: ❲open❳

👎 no

    👎 no

✓ Rejected proposal 👎

status: ❲open❳

👎 no

✓ Accepted proposal ✓

status: ❲open❳

👍 yes

    👍 yes

✓ Committed new identity 'c96e764965aaeff1c6ea3e5b97e2b9828773c8b0' 🌱

status: ❲committed❳

👍 yes

✓ Identity proposal 'dc00640d3152ea5f1df59f39f2f5983d2ad21810' created 🌱

status: ❲open❳

👎 no

✓ Closed identity proposal 'dc00640d3152ea5f1df59f39f2f5983d2ad21810'

status: ❲closed❳

👎 no

06d9efa2a9aad06bfdf25a25690e1ec7db2c3c39 "Add Bob"          ❲committed❳

dc00640d3152ea5f1df59f39f2f5983d2ad21810 "Update threshold" ❲closed❳

status: ❲closed❳

👎 no

✓ Project heartwood created

✓ Syncing inventory..

✓ Project heartwood created

✓ Pushing HEAD to storage...

✓ Analyzing remotes...

✓ Patch d4ef85f57a849bd845915d7a66a2192cd23811f6 created 🌱

❲YOU PROPOSED❳

❲OTHERS PROPOSED❳

✓ Pushing HEAD to storage...

✓ Analyzing remotes...

✓ Patch d4ef85f57a849bd845915d7a66a2192cd23811f6 updated 🌱

✓ Performing patch checkout...

✓ Switched to branch patch/d4ef85f57a8

! Warning: Failed to untrack repository: failed to connect to node: No such file or directory (os error 2)

! Warning: Make sure to untrack this repository when your node is running

✓ Successfully removed project rad:z42hL2jL4XNk6K8oHQaSWfMgCL7ji from storage

    let passphrase = if options.stdin {

        term::passphrase_stdin()

    } else {

        term::passphrase_confirm()

    }?;

        "Your Radicle ID is {}. This identifies your device.",

        term::format::highlight(profile.did())

    // TODO: Only show this if we're not authenticated.

        let passphrase = if options.stdin {

            term::passphrase_stdin()

        } else {

            term::passphrase()

        }?;

    let path = PathBuf::from(payload.name());

    match term::Editor::new().extension("json").edit(payload) {

        Ok(Some(updated_payload)) => {

        _ => return Err(anyhow!("Operation aborted!")),

        match term::Editor::new().edit(yaml)? {

                term::success!("Rejected proposal 👎");

            term::format::positive("👍 yes")

            term::format::negative("👎 no")

            term::format::highlight(".").to_string()

            term::format::highlight(path.display()).to_string()

        term::input("Name", default).unwrap()

        .unwrap_or_else(|| term::input("Description", None).unwrap());

            term::input("Default branch", Some(head)).unwrap()

                let (comment_id, _) = term::comment_select(&issue).unwrap();

                issue.react(*comment_id, reaction, &signer)?;

            if let Ok(Some(text)) = term::Editor::new().edit(&doc) {

            term::format::tertiary(id.urn().as_str()),

            term::format::secondary(head.as_str()),

        MergeStyle::Commit => term::format::yellow(merge_style.to_string())

    let merge_msg = match term::Editor::new().extension("git-commit").edit(merge_msg) {

        Ok(Some(s)) => s

        _ => anyhow::bail!("user aborted merge"),

        return Ok(term::format::dim("up to date").to_string());

    let mut oid = term::format::secondary(term::format::oid(*revision_oid)).to_string();

            return Ok(());

use unicode_width::UnicodeWidthStr;

    term::print(term::format::badge_secondary("YOU PROPOSED"));

    term::print(term::format::badge_secondary("OTHERS PROPOSED"));

        author_info.push(term::format::secondary("(you)").to_string());

    author_info.push(term::format::dim(term::format::timestamp(&patch.timestamp())).to_string());

            badges.push(term::format::secondary("(delegate)").to_string());

            badges.push(term::format::secondary("(you)").to_string());

                " ".repeat(prefix.width()),

            badges.push(term::format::secondary("(delegate)").to_string());

            badges.push(term::format::secondary("(you)").to_string());

                " ".repeat(prefix.width()),

    table.push([

        term::format::style("ID").to_string(),

        term::format::tertiary(did).to_string(),

    ]);

    table.push([

        term::format::style("Node ID").to_string(),

        term::format::tertiary(node_id).to_string(),

    ]);

    table.push([

        term::format::style("Key (hash)").to_string(),

        term::format::tertiary(ssh_short).to_string(),

    ]);

    table.push([

        term::format::style("Key (full)").to_string(),

        term::format::tertiary(ssh_long).to_string(),

    ]);

        term::format::style("Storage (git)").to_string(),

        term::format::tertiary(storage_path.display()).to_string(),

        term::format::style("Storage (keys)").to_string(),

        term::format::tertiary(keys_path.display()).to_string(),

        term::format::style("Node (socket)").to_string(),

        term::format::tertiary(node_path.join("radicle.sock").display()).to_string(),

pub mod ansi;

pub mod cell;

pub mod editor;

pub use ansi::{paint, Paint};

pub use editor::Editor;

pub use inquire::ui::Styled;

                Paint::red("=="),

                Paint::red("Error:"),

                Paint::red(format!("rad-{}:", help.name)),

                Paint::red(err.to_string()),

                eprintln!("{}", Paint::yellow(hint));

pub fn style<T>(item: T) -> Paint<T> {

    paint(item)

}

//! A dead simple ANSI terminal color painting library.

//!

//! This library is a port of the `yansi` crate.

//! Copyright (c) 2017 Sergio Benitez

//!

mod color;

mod paint;

mod style;

#[cfg(test)]

mod tests;

mod windows;

pub use color::Color;

pub use paint::paint;

pub use paint::Paint;

pub use style::Style;

use std::fmt;

use super::{Paint, Style};

/// An enum representing an ANSI color code.

#[derive(Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone)]

pub enum Color {

    /// No color has been set. Nothing is changed when applied.

    #[default]

    Unset,

    /// Black #0 (foreground code `30`, background code `40`).

    Black,

    /// Red: #1 (foreground code `31`, background code `41`).

    Red,

    /// Green: #2 (foreground code `32`, background code `42`).

    Green,

    /// Yellow: #3 (foreground code `33`, background code `43`).

    Yellow,

    /// Blue: #4 (foreground code `34`, background code `44`).

    Blue,

    /// Magenta: #5 (foreground code `35`, background code `45`).

    Magenta,

    /// Cyan: #6 (foreground code `36`, background code `46`).

    Cyan,

    /// White: #7 (foreground code `37`, background code `47`).

    White,

    /// A color number from 0 to 255, for use in 256-color terminals.

    Fixed(u8),

    /// A 24-bit RGB color, as specified by ISO-8613-3.

    RGB(u8, u8, u8),

}

impl Color {

    /// Constructs a new `Paint` structure that encapsulates `item` with the

    /// foreground color set to the color `self`.

    #[inline]

    pub fn paint<T>(self, item: T) -> Paint<T> {

        Paint::new(item).fg(self)

    }

    /// Constructs a new `Style` structure with the foreground color set to the

    /// color `self`.

    #[inline]

    pub const fn style(self) -> Style {

        Style::new(self)

    }

    pub(crate) fn ansi_fmt(&self, f: &mut dyn fmt::Write) -> fmt::Result {

        match *self {

            Color::Unset => Ok(()),

            Color::Black => write!(f, "0"),

            Color::Red => write!(f, "1"),

            Color::Green => write!(f, "2"),

            Color::Yellow => write!(f, "3"),

            Color::Blue => write!(f, "4"),

            Color::Magenta => write!(f, "5"),

            Color::Cyan => write!(f, "6"),

            Color::White => write!(f, "7"),

            Color::Fixed(num) => write!(f, "8;5;{num}"),

            Color::RGB(r, g, b) => write!(f, "8;2;{r};{g};{b}"),

        }

    }

}

use std::fmt;

use unicode_width::UnicodeWidthStr;

use super::color::Color;

use super::style::{Property, Style};

/// A structure encapsulating an item and styling.

#[derive(Debug, Default, Eq, PartialEq, Ord, PartialOrd, Hash, Copy, Clone)]

pub struct Paint<T> {

    pub item: T,

    pub style: Style,

}

impl Paint<&str> {

    /// Return plain content.

    pub fn content(&self) -> &str {

        self.item

    }

}

impl Paint<String> {

    /// Return plain content.

    pub fn content(&self) -> &str {

        self.item.as_str()

    }

}

impl<T> From<T> for Paint<T> {

    fn from(value: T) -> Self {

        Self::new(value)

    }

}

impl From<&str> for Paint<String> {

    fn from(item: &str) -> Self {

        Self::new(item.to_string())

    }

}

impl<T> Paint<T> {

    /// Constructs a new `Paint` structure encapsulating `item` with no set

    /// styling.

    #[inline]

    pub const fn new(item: T) -> Paint<T> {

        Paint {

            item,

            style: Style {

                foreground: Color::Unset,

                background: Color::Unset,

                properties: Property::new(),

                wrap: false,

            },

        }

    }

    /// Constructs a new _wrapping_ `Paint` structure encapsulating `item` with

    /// default styling.

    ///

    /// A wrapping `Paint` converts all color resets written out by the internal

    /// value to the styling of itself. This allows for seamless color wrapping

    /// of other colored text.

    ///

    /// # Performance

    ///

    /// In order to wrap an internal value, the internal value must first be

    /// written out to a local buffer and examined. As a result, displaying a

    /// wrapped value is likely to result in a heap allocation and copy.

    #[inline]

    pub const fn wrapping(item: T) -> Paint<T> {

        Paint::new(item).wrap()

    }

    /// Constructs a new `Paint` structure encapsulating `item` with the

    /// foreground color set to the RGB color `r`, `g`, `b`.

    #[inline]

    pub const fn rgb(r: u8, g: u8, b: u8, item: T) -> Paint<T> {

        Paint::new(item).fg(Color::RGB(r, g, b))

    }

    /// Constructs a new `Paint` structure encapsulating `item` with the

    /// foreground color set to the fixed 8-bit color `color`.

    #[inline]

    pub const fn fixed(color: u8, item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Fixed(color))

    }

    pub const fn red(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Red)

    }

    pub const fn black(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Black)

    }

    pub const fn yellow(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Yellow)

    }

    pub const fn green(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Green)

    }

    pub const fn cyan(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Cyan)

    }

    pub const fn blue(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Blue)

    }

    pub const fn magenta(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::Magenta)

    }

    pub const fn white(item: T) -> Paint<T> {

        Paint::new(item).fg(Color::White)

    }

    /// Retrieves the style currently set on `self`.

    #[inline]

    pub const fn style(&self) -> Style {

        self.style

    }

    /// Retrieves a borrow to the inner item.

    #[inline]

    pub const fn inner(&self) -> &T {

        &self.item

    }

    /// Sets the style of `self` to `style`.

    #[inline]

    pub fn with_style(mut self, style: Style) -> Paint<T> {

        self.style = style;

        self

    }

    /// Makes `self` a _wrapping_ `Paint`.

    ///

    /// A wrapping `Paint` converts all color resets written out by the internal

    /// value to the styling of itself. This allows for seamless color wrapping

    /// of other colored text.

    ///

    /// # Performance

    ///

    /// In order to wrap an internal value, the internal value must first be

    /// written out to a local buffer and examined. As a result, displaying a

    /// wrapped value is likely to result in a heap allocation and copy.

    #[inline]

    pub const fn wrap(mut self) -> Paint<T> {

        self.style.wrap = true;

        self

    }

    /// Sets the foreground to `color`.

    #[inline]

    pub const fn fg(mut self, color: Color) -> Paint<T> {

        self.style.foreground = color;

        self

    }

    /// Sets the background to `color`.

    #[inline]

    pub const fn bg(mut self, color: Color) -> Paint<T> {

        self.style.background = color;

        self

    }

    pub fn bold(mut self) -> Self {

        self.style.properties.set(Property::BOLD);

        self

    }

    pub fn dim(mut self) -> Self {

        self.style.properties.set(Property::DIM);

        self

    }

    pub fn italic(mut self) -> Self {

        self.style.properties.set(Property::ITALIC);

        self

    }

    pub fn underline(mut self) -> Self {

        self.style.properties.set(Property::UNDERLINE);

        self

    }

    pub fn invert(mut self) -> Self {

        self.style.properties.set(Property::INVERT);

        self

    }

    pub fn strikethrough(mut self) -> Self {

        self.style.properties.set(Property::STRIKETHROUGH);

        self

    }

    pub fn blink(mut self) -> Self {

        self.style.properties.set(Property::BLINK);

        self

    }

    pub fn hidden(mut self) -> Self {

        self.style.properties.set(Property::HIDDEN);

        self

    }

}

impl<T: UnicodeWidthStr> UnicodeWidthStr for Paint<T> {

    fn width(&self) -> usize {

        self.item.width()

    }

    fn width_cjk(&self) -> usize {

        self.item.width_cjk()

    }

}

impl<T: fmt::Display> fmt::Display for Paint<T> {

    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

        if Paint::is_enabled() && self.style.wrap {

            let mut prefix = String::new();

            prefix.push_str("\x1B[0m");

            self.style.fmt_prefix(&mut prefix)?;

            self.style.fmt_prefix(f)?;

            let item = format!("{}", self.item).replace("\x1B[0m", &prefix);

            fmt::Display::fmt(&item, f)?;

            self.style.fmt_suffix(f)

        } else if Paint::is_enabled() {

            self.style.fmt_prefix(f)?;

            fmt::Display::fmt(&self.item, f)?;

            self.style.fmt_suffix(f)

        } else {

            fmt::Display::fmt(&self.item, f)

        }

    }

}

impl Paint<()> {

    /// Returns `true` if coloring is enabled and `false` otherwise.