runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v3

      - run: cargo build --all-features

        env:

          RUSTFLAGS: -D warnings

    runs-on: ubuntu-latest

    steps:

      - uses: actions/checkout@v3

      - run: cargo doc --all --all-features

        env:

          RUSTDOCFLAGS: -D warnings

        "homepage": "https://github.com/nmattia/niv",

        "owner": "nmattia",

        "repo": "niv",

        "type": "tarball",

        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

    },

    "nixpkgs": {

        "homepage": "",

        "owner": "oxalica",

        "repo": "rust-overlay",

        "type": "tarball",

        "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"

    }

}

        })

        .unwrap_or_else(|| String::from("unknown"));

    println!("cargo:rustc-rerun-if-changed=.git/HEAD");

}

                }

                Value(val) if id.is_none() => {

                    let val = val.to_string_lossy();

                    id = Some(val);

                }

                    git::read_gitsigners(repo).context("error reading .gitsigners file")?;

                if ssh_keys.contains(&ssh_key) {

                    git::add_gitsigners(repo, [node_id])?;

                }

            }

                term::format::yellow(oid),

            );

            if let Ok(parent) = tip.parent_id(0) {

            }

            println!("blob   {}", blob.id());

            println!();

            if let Some(msg) = tip.message() {

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .identity_of(profile.id())

    let repository = profile.storage.repository(id)?;

    let mut patches = Patches::open(*profile.id(), &repository)?;

        "{} {} {} ({}) by {} into {} ({}) via {}...",

        term::format::bold("Merging"),

        term::format::tertiary(term::format::cob(&patch_id)),

        term::format::secondary(term::format::oid(revision.oid)),

        term::format::tertiary(patch.author().id),

        term::format::highlight(branch),

    write!(&mut merge_msg, "\n\n")?;

    if !description.is_empty() {

        write!(&mut merge_msg, "\n\n")?;

    }

    writeln!(&mut merge_msg, "Rad-Author: {}", patch.author().id())?;

    writeln!(&mut merge_msg)?;

    writeln!(&mut merge_msg, "{}", MERGE_HELP_MSG.trim())?;

    let ahead = term::format::positive(a);

    let behind = term::format::negative(b);

}

/// Make a human friendly string for commit version information.

) -> anyhow::Result<Vec<git::raw::Commit<'a>>> {

    let mut commits = Vec::new();

    let mut revwalk = repo.revwalk()?;

    for rev in revwalk {

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

    let commit_message = head_commit

        .message()

        .ok_or(anyhow!("commit summary is not valid UTF-8; aborting"))?;

    let (title, description) = message.split_once("\n\n").unwrap_or((&message, ""));

    let (title, description) = (title.trim(), description.trim());

    let description = description.replace(PATCH_MSG.trim(), ""); // Delete help message.

    term::info!(

        "{} {} ({}) -> {} ({})",

        term::format::tertiary(term::format::cob(&patch_id)),

        term::format::secondary(term::format::oid(current_revision.oid)),

        term::format::dim(format!("R{}", current_version + 1)),

        term::format::secondary(term::format::oid(*head)),

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

    let patches = patch::Patches::open(profile.public_key, storage)?;

    let Some(patch) = patches.get(patch_id)? else {

    };

    term::blank();

    term::blank();

    term::patch::print_title_desc(patch.title(), patch.description().unwrap_or(""));

    let repository = profile.storage.repository(id)?;

    let _project = repository

        .identity_of(profile.id())

    let mut patches = Patches::open(*profile.id(), &repository)?;

    let patch_id = options.id;

    let mut patch = patches

        .get_mut(&patch_id)

    let patch_id_pretty = term::format::tertiary(term::format::cob(&patch_id));

    let revision_ix = options.revision.unwrap_or_else(|| patch.version());

    let (revision_id, _) = patch

        "{} {} {} by {}?",

        verdict_pretty,

        patch_id_pretty,

        term::format::tertiary(patch.author().id())

    )) {

        anyhow::bail!("Patch review aborted");

/// Get the name of the remote of the given branch, if any.

pub fn branch_remote(repo: &Repository, branch: &str) -> anyhow::Result<String> {

    let cfg = repo.config()?;

    Ok(remote)

}

        Ok(_) => process::exit(0),

        Err(err) => {

            if let Some(err) = err {

            }

            process::exit(1);

        }

fn print_version() {

    if VERSION.contains("-dev") {

    } else {

    }

}

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

    print_version();

    println!();

    rad_help::run(Default::default(), term::profile)

            args.to_vec(),

        ),

        _ => {

            let status = process::Command::new(exe.clone()).args(args).status();

            match status {

    match cmd.run(options, self::profile) {

        Ok(()) => process::exit(0),

        Err(err) => {

            process::exit(1);

        }

    }

pub fn format(arg: lexopt::Arg) -> OsString {

    match arg {

        lexopt::Arg::Value(val) => val,

    }

}

    let start = node.chars().take(7).collect::<String>();

    let end = node.chars().skip(node.len() - 7).collect::<String>();

}

/// Format a git Oid.

                term::format::dim(username)

            )

        } else {

        }

    }

}

}

pub fn badge_primary<D: std::fmt::Display>(input: D) -> String {

}

pub fn badge_positive<D: std::fmt::Display>(input: D) -> String {

}

pub fn badge_negative<D: std::fmt::Display>(input: D) -> String {

}

pub fn badge_secondary<D: std::fmt::Display>(input: D) -> String {

}

pub fn bold<D: std::fmt::Display>(input: D) -> String {

pub use tip;

pub fn success_args(args: fmt::Arguments) {

}

pub fn tip_args(args: fmt::Arguments) {

}

pub fn width() -> Option<usize> {

}

pub fn print(msg: impl fmt::Display) {

}

pub fn prefixed(prefix: &str, text: &str) -> String {

    text.split('\n')

        .collect()

}

pub fn help(name: &str, version: &str, description: &str, usage: &str) {

}

pub fn usage(name: &str, usage: &str) {

    eprintln!(

        "{} {}\n{}",

        style("==").red(),

        style(prefixed(TAB, usage)).red().dim()

    );

}

pub fn eprintln(prefix: impl fmt::Display, msg: impl fmt::Display) {

}

pub fn indented(msg: impl fmt::Display) {

}

pub fn subcommand(msg: impl fmt::Display) {

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

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

        if let Some(val) = &self.option {

        } else {

            write!(f, "")

        }

}

fn _info(args: std::fmt::Arguments) {

}

/// Print title and description in a text box.

pub fn print_title_desc(title: &str, description: &str) {

    term::print(title_pretty);

    term::blank();

            for (i, cell) in row.iter().enumerate() {

                if i == cells - 1 || self.opts.overflow {

                } else {

                    write!(

                        output,

        key: crypto::PublicKey,

    ) -> Result<Self, storage::error::Identity> {

        let repo = repo.as_raw();

        let payload = Payload {

            name: Name(name.to_owned()),

            key,

        delegate: crypto::PublicKey,

    ) -> Result<Self, storage::error::Identity> {

        let repo = repo.as_raw();

        let payload = Payload {

            name: Name(name.to_owned()),

            delegates: Some(delegate).into_iter().collect(),

        typename: &crate::TypeName,

        object_id: &ObjectId,

    ) -> Result<object::Objects, Self::ObjectsError> {

        let remotes = self

            .raw

            .references_glob(&glob)?

        for r in self.raw.references_glob("refs/rad/*")? {

            let r = r?;

            let name = r.name().unwrap();

            let oid = r

                .target()

                .map(ObjectId::from)

impl fmt::Debug for Digest {

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

    }

}

impl fmt::Display for Digest {

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

        for byte in &self.0 {

        }

        Ok(())

    }

impl fmt::Debug for Signature {

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

    }

}

impl fmt::Debug for PublicKey {

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

    }

}

        let sha = sha2::Sha256::digest(&buf).to_vec();

        let encoded = base64::encode_config(sha, base64::STANDARD_NO_PAD);

    }

    #[cfg(test)]

    fn index(&self, key: &K) -> &Self::Output {

        self.get(key)

    }

}

        let expected: &[&[i32]] = &[&[0, 1, 2, 3], &[0, 2, 1, 3]];

        let actual = dag.sorted(fastrand::Rng::new());

    }

    #[test]

                    }

                    _ => Json(Error {

                        success: false,

                    }),

                };

                    }),

                    _ => Json(Error {

                        success: false,

                    }),

                };

            Err(Error::Backend)

        }

        Err(err) => {

        }

    }

}

                        handle.shutdown().ok();

                        break;

                    }

                    stream.flush().ok();

                    stream.shutdown(net::Shutdown::Both).ok();

            {

                match result.result {

                    Ok(updated) => {

                        for update in updated {

                        }

                    }

                    Err(err) => {

                        writeln!(

                            writer,

                        )?;

                    }

                }

            }

        }

        Ok(FetchLookup::NotFound) => {

        }

        Ok(FetchLookup::NotTracking) => {

        }

        Ok(FetchLookup::Error(err)) => {

        }

    }

    Ok(())

                    Level::Debug => message.dimmed(),

                    Level::Trace => message.white().dimmed(),

                };

            }

        }

    }

impl fmt::Debug for Command {

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

        match self {

            Self::QueryState { .. } => write!(f, "QueryState(..)"),

        }

    }

impl fmt::Display for DisconnectReason {

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

        match self {

        }

    }

}

        match self {

            Self::Initialize { .. } => write!(f, "Initialize(..)"),

            Self::Subscribe(Subscribe { since, until, .. }) => {

            }

            Self::Announcement(Announcement { node, message, .. }) => {

            }

            Self::Fetch { rid } => write!(f, "Fetch({rid})"),

            Self::FetchOk { rid } => write!(f, "FetchOk({rid})"),

        }

            target => {

                if self.enabled(record.metadata()) {

                    let current = std::thread::current();

                    let s = if let Some(name) = current.name() {

                    } else {

                        msg

                    };

                    self.schedule(&node, o);

                }

            } else {

            }

        }

        !self.is_done()

    let (seeds, results) = match alice.handle.fetch(acme).unwrap() {

        FetchLookup::Found { seeds, results } => (seeds, results),

    };

    assert_eq!(seeds, nonempty::NonEmpty::new(bob.id));

    match lookup {

        // Drain the channel.

        FetchLookup::Found { seeds, results } => for _ in results.iter().take(seeds.len()) {},

    }

    rad::fork(acme, &alice.signer, &alice.storage).unwrap();

    match alice.handle.fetch(acme).unwrap() {

        FetchLookup::Found { seeds, results } => for _ in results.iter().take(seeds.len()) {},

    }

    // Fetch again! This time, everything's up to date.

    match alice.handle.fetch(acme).unwrap() {

        FetchLookup::Found { seeds, results } => for _ in results.iter().take(seeds.len()) {},

    }

}

impl std::fmt::Debug for Peer {

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

        match self {

            Self::Connected { link, id } => write!(f, "Connected({link:?}, {id})"),

            Self::Disconnected { reason, id } => write!(f, "Disconnected({reason}, {id:?})"),

            Self::Upgrading { fetch, link, id } => write!(

        if let Self::Connecting { link } = self {

            *self = Self::Connected { link: *link, id };

        } else {

        }

    }

        } else if let Self::Connecting { .. } = self {

            *self = Self::Disconnected { id: None, reason };

        } else {

        }

    }

    let profile = match radicle::Profile::load() {

        Ok(profile) => profile,

        Err(err) => {

            std::process::exit(1);

        }

    };

    if let Err(err) = radicle_remote_helper::run(profile) {

        std::process::exit(1);

    }

}

        &profile.storage,

    )?;

    Ok(())

}

    let (_, id) = radicle::rad::remote(&repo)?;

    let output = radicle::git::run::<_, _, &str, &str>(&cwd, ["push", "rad"], None)?;

    let signer = profile.signer()?;

    let project = profile.storage.repository(id)?;

    radicle::Node::new(profile.socket()).announce_refs(id)?;

    println!("ok: {}", sigrefs.signature);

    Ok(())

    merge: &str,

) -> Result<(), git2::Error> {

    let mut config = repo.config()?;

    config.remove_multivar(&branch_remote, ".*").or_else(|e| {

        if ext::is_not_found_err(&e) {

    #[quickcheck]

    fn prop_json_eq_str(pk: PublicKey, proj: Id, did: Did) {

        let json = serde_json::to_string(&pk).unwrap();

        let json = serde_json::to_string(&proj).unwrap();

        assert_eq!(format!("\"{}\"", proj.urn()), json);

        let json = serde_json::to_string(&did).unwrap();

    }

    #[test]

impl fmt::Debug for Id {

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

    }

}

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

        match self {

            Self::Updated { name, old, new } => {

            }

            Self::Created { name, oid } => {

            }

            Self::Deleted { name, oid } => {

            }

            Self::Skipped { name, oid } => {

            }

        }

    }

                let name = r.name().ok_or(Error::InvalidRef)?;

                let oid = r.target().ok_or(Error::InvalidRef)?;

            }

        }

        Ok(())

            let name = r.name().ok_or(Error::InvalidRef)?;

            let oid = r.target().ok_or(Error::InvalidRef)?;

        }

        Ok(())

    }

            Some(&sigref),

            &author,

            &author,

            &tree,

            &parent.iter().collect::<Vec<&git2::Commit>>(),

        );