// Analyze merge

    //

    let patch_commit = repo

        .context("patch head not found in local repository")?;

    let (merge, _merge_pref) = repo.merge_analysis(&[&patch_commit])?;

        //

        // Let's check if there are potential merge conflicts.

        let our_commit = head.peel_to_commit()?;

        let index = repo

            .merge_commits(&our_commit, &their_commit, None)

        anyhow::bail!(

            "no merge is possible between {} and {}",

            head_oid,

        );

    };

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

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

        term::format::dim(format!("R{revision_ix}")),

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

        term::format::highlight(branch),

        term::format::parens(term::format::secondary(term::format::oid(head_oid))),

            merge_commit(&repo, patch_id, &patch_commit, &patch, signer.public_key())?;

        }

        MergeStyle::FastForward => {

        }

    }

        "Updated {} {} -> {} via {}",

        term::format::highlight(branch),

        term::format::secondary(term::format::oid(head_oid)),

        merge_style_pretty

    );

            let (_, rev) = patch

                .latest()

                .ok_or(anyhow!("patch does not have any revisions"))?;

            let remote = stored.remote(&author)?;

            // Find a ref in storage that points to our patch, so that we can fetch the patch

                &RefString::try_from(author.to_string())?,

                patch_branch,

            );

            // Fetch only the ref pointing to the patch revision.

            working.remote_anonymous(url.to_string().as_str())?.fetch(

    for (id, patch, clock) in proposed {

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

            continue;

        }

        if **patch.head() == patch_head {

                term::format::dim(format!("R{}", patch.version())).into(),

            ])

            .space()

            .space()

            .extend(common::pretty_sync_status(

                repository.raw(),

                target_head,

            )?),

        )

        // Don't show an "update" line for the first revision.

        if revision_id != latest {

            timeline.push((

                term::Line::spaced(

                    [

                        term::format::tertiary("↑").into(),

                        term::format::default("updated to").into(),

                        term::format::dim(revision_id).into(),

                        term::format::parens(term::format::secondary(term::format::oid(

                        )))

                        .into(),

                    ]

            ));

        }

            let peer = repository.remote(&merge.node)?;

            let mut badges = Vec::new();

                ),

            ));

        }

            let verdict = match review.verdict() {

                Some(Verdict::Accept) => term::format::positive(term::format::dim("✓ accepted")),

                Some(Verdict::Reject) => term::format::negative(term::format::dim("✗ rejected")),

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

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

        term::format::parens(term::format::secondary(term::format::oid(

        ))),

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

    );

    // Difference between the two revisions.

    let head_oid = branch_oid(head_branch)?;

    Ok(())

}

    // TODO(cloudhead): Handle error.

    let (_, current_revision) = patch.latest().unwrap();

        term::info!("Nothing to do, patch is already up to date.");

        return Ok(());

    }

            json!({

                "id": id,

                "description": rev.description(),

                "merges": rev.merges().collect::<Vec<_>>(),

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

                "reviews": rev.reviews().collect::<Vec<_>>(),

            })

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

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

pub struct Patch {

    /// Title of the patch.

    /// Patch description.

    /// Current state of the patch.

    /// Target this patch is meant to be merged in.

    /// Associated tags.

    /// List of patch revisions. The initial changeset is part of the

    /// first revision.

    /// Timeline of operations.

}

impl Semilattice for Patch {

}

impl Patch {

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

        self.title.get().get()

    }

    pub fn state(&self) -> State {

        *self.state.get().get()

    }

    pub fn target(&self) -> MergeTarget {

        *self.target.get().get()

    }

    pub fn timestamp(&self) -> Timestamp {

        self.revisions()

            .next()

            .timestamp

    }

    pub fn tags(&self) -> impl Iterator<Item = &Tag> {

        self.tags.iter()

    }

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

        self.description.get().get()

    }

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

        &self

            .revisions()

            .author

    }

    pub fn revisions(&self) -> impl DoubleEndedIterator<Item = (&RevisionId, &Revision)> {

        self.timeline.iter().filter_map(|(_, id)| {

            self.revisions

        })

    }

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

        &self

            .latest()

            .oid

    }

    pub fn version(&self) -> RevisionIx {

        self.revisions

            .len()

            .expect("Patch::version: at least one revision is present")

    }

    pub fn latest(&self) -> Option<(&RevisionId, &Revision)> {

        self.revisions().next_back()

    }

    pub fn is_open(&self) -> bool {

        matches!(self.state.get().get(), State::Open)

    }

    pub fn is_archived(&self) -> bool {

        matches!(self.state.get().get(), &State::Archived)

    }

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

pub struct Revision {

    /// Author of the revision.

    /// Revision description.

    /// Base branch commit, used as a merge base.

    /// Reference to the Git object containing the code (revision head).

    /// Discussion around this revision.

    /// Merges of this revision into other repositories.

    /// Reviews of this revision's changes (one per actor).

    /// When this revision was created.

}

impl Revision {

        self.description.get()

    }

    pub fn merges(&self) -> impl Iterator<Item = &Merge> {

        self.merges.iter().map(|m| m.get())

    }

    pub fn reviews(&self) -> impl DoubleEndedIterator<Item = (&PublicKey, &Review)> {

        self.reviews.iter()

    }

#[serde(rename_all = "camelCase")]

pub struct CodeComment {

    /// Code location of the comment.

    /// Comment.

    /// Timestamp.

}

/// A patch review on a revision.

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

pub struct Review {

    /// Review verdict.

    /// Review general comment.

    /// Review inline code comments.

    /// Review timestamp.

}

impl Serialize for Review {

        }

    }

    pub fn verdict(&self) -> Option<Verdict> {

        self.verdict.get().as_ref().copied()

    }

    pub fn inline(&self) -> impl Iterator<Item = &CodeComment> {

        self.inline.iter().map(|m| m.get())

    }

    pub fn comment(&self) -> Option<&str> {

        self.comment.get().as_ref().map(|m| m.get().as_str())

    }

    pub fn timestamp(&self) -> Timestamp {

        *self.timestamp.get()

    }