2022-11-26 23:57:50 +00:00
|
|
|
// Copyright 2020 The Jujutsu Authors
|
2020-12-12 08:00:42 +00:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
|
2021-10-07 05:50:11 +00:00
|
|
|
use std::collections::{HashMap, HashSet};
|
2021-04-07 06:05:16 +00:00
|
|
|
use std::io;
|
2023-01-14 10:32:01 +00:00
|
|
|
use std::ops::AddAssign;
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2021-06-09 20:57:48 +00:00
|
|
|
use itertools::Itertools;
|
2023-01-19 04:25:18 +00:00
|
|
|
use jujutsu_lib::backend::{ChangeId, ObjectId, Signature, Timestamp};
|
2021-05-15 16:16:31 +00:00
|
|
|
use jujutsu_lib::commit::Commit;
|
2022-02-02 18:14:03 +00:00
|
|
|
use jujutsu_lib::op_store::WorkspaceId;
|
2021-05-15 16:16:31 +00:00
|
|
|
use jujutsu_lib::repo::RepoRef;
|
2021-10-07 05:50:11 +00:00
|
|
|
use jujutsu_lib::revset::RevsetExpression;
|
2023-01-14 10:43:23 +00:00
|
|
|
use jujutsu_lib::rewrite::merge_commit_trees;
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2021-06-02 22:50:08 +00:00
|
|
|
use crate::formatter::Formatter;
|
2023-01-23 02:38:16 +00:00
|
|
|
use crate::time_util;
|
2020-12-12 08:00:42 +00:00
|
|
|
|
|
|
|
pub trait Template<C> {
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()>;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 02:38:16 +00:00
|
|
|
impl Template<()> for Signature {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
2023-01-22 12:16:52 +00:00
|
|
|
write!(formatter, "{}", self.name)?;
|
|
|
|
write!(formatter, " <")?;
|
|
|
|
write!(formatter.labeled("email"), "{}", self.email)?;
|
|
|
|
write!(formatter, ">")?;
|
|
|
|
Ok(())
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for String {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(self)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for Timestamp {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(&time_util::format_absolute_timestamp(self))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for bool {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(if *self { "true" } else { "false" })
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-12-12 08:00:42 +00:00
|
|
|
// TODO: figure out why this lifetime is needed
|
|
|
|
pub struct LabelTemplate<'a, C> {
|
|
|
|
content: Box<dyn Template<C> + 'a>,
|
|
|
|
labels: Vec<String>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C> LabelTemplate<'a, C> {
|
2023-01-07 19:14:01 +00:00
|
|
|
pub fn new(content: Box<dyn Template<C> + 'a>, labels: Vec<String>) -> Self {
|
2020-12-12 08:00:42 +00:00
|
|
|
LabelTemplate { content, labels }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C> Template<C> for LabelTemplate<'a, C> {
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2020-12-12 08:00:42 +00:00
|
|
|
for label in &self.labels {
|
2023-01-12 08:00:12 +00:00
|
|
|
formatter.push_label(label)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-06-02 22:50:08 +00:00
|
|
|
self.content.format(context, formatter)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
for _label in &self.labels {
|
2023-01-12 08:00:12 +00:00
|
|
|
formatter.pop_label()?;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-04-07 06:05:16 +00:00
|
|
|
Ok(())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-07 19:14:01 +00:00
|
|
|
pub type DynamicLabelFunction<'a, C> = Box<dyn Fn(&C) -> Vec<String> + 'a>;
|
|
|
|
|
2020-12-12 08:00:42 +00:00
|
|
|
// TODO: figure out why this lifetime is needed
|
|
|
|
pub struct DynamicLabelTemplate<'a, C> {
|
|
|
|
content: Box<dyn Template<C> + 'a>,
|
2023-01-07 19:14:01 +00:00
|
|
|
label_property: DynamicLabelFunction<'a, C>,
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C> DynamicLabelTemplate<'a, C> {
|
|
|
|
pub fn new(
|
|
|
|
content: Box<dyn Template<C> + 'a>,
|
2023-01-07 19:14:01 +00:00
|
|
|
label_property: DynamicLabelFunction<'a, C>,
|
2020-12-12 08:00:42 +00:00
|
|
|
) -> Self {
|
|
|
|
DynamicLabelTemplate {
|
|
|
|
content,
|
|
|
|
label_property,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C> Template<C> for DynamicLabelTemplate<'a, C> {
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2020-12-12 08:00:42 +00:00
|
|
|
let labels = self.label_property.as_ref()(context);
|
|
|
|
for label in &labels {
|
2023-01-12 08:00:12 +00:00
|
|
|
formatter.push_label(label)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-06-02 22:50:08 +00:00
|
|
|
self.content.format(context, formatter)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
for _label in &labels {
|
2023-01-12 08:00:12 +00:00
|
|
|
formatter.pop_label()?;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-04-07 06:05:16 +00:00
|
|
|
Ok(())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: figure out why this lifetime is needed
|
|
|
|
pub struct ListTemplate<'a, C>(pub Vec<Box<dyn Template<C> + 'a>>);
|
|
|
|
|
|
|
|
impl<'a, C> Template<C> for ListTemplate<'a, C> {
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2020-12-12 08:00:42 +00:00
|
|
|
for template in &self.0 {
|
2021-06-02 22:50:08 +00:00
|
|
|
template.format(context, formatter)?
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-04-07 06:05:16 +00:00
|
|
|
Ok(())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub trait TemplateProperty<C, O> {
|
|
|
|
fn extract(&self, context: &C) -> O;
|
|
|
|
}
|
|
|
|
|
2023-01-23 03:03:13 +00:00
|
|
|
/// Adapter to drop template context.
|
|
|
|
pub struct Literal<O>(pub O);
|
|
|
|
|
|
|
|
impl<C, O: Template<()>> Template<C> for Literal<O> {
|
|
|
|
fn format(&self, _context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
self.0.format(&(), formatter)
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 03:03:13 +00:00
|
|
|
impl<C, O: Clone> TemplateProperty<C, O> for Literal<O> {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, _context: &C) -> O {
|
2023-01-23 03:03:13 +00:00
|
|
|
self.0.clone()
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:02:46 +00:00
|
|
|
/// Adapter to extract context-less template value from property for displaying.
|
|
|
|
pub struct FormattablePropertyTemplate<'a, C, O> {
|
|
|
|
property: Box<dyn TemplateProperty<C, O> + 'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C, O> FormattablePropertyTemplate<'a, C, O> {
|
|
|
|
pub fn new(property: Box<dyn TemplateProperty<C, O> + 'a>) -> Self {
|
|
|
|
FormattablePropertyTemplate { property }
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-22 23:02:46 +00:00
|
|
|
impl<C, O> Template<C> for FormattablePropertyTemplate<'_, C, O>
|
|
|
|
where
|
|
|
|
O: Template<()>,
|
|
|
|
{
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2023-01-22 23:02:46 +00:00
|
|
|
let template = self.property.extract(context);
|
|
|
|
template.format(&(), formatter)
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct DescriptionProperty;
|
|
|
|
|
2022-05-21 17:20:03 +00:00
|
|
|
impl TemplateProperty<Commit, String> for DescriptionProperty {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> String {
|
2023-01-14 10:32:01 +00:00
|
|
|
match context.description() {
|
|
|
|
s if s.is_empty() => "(no description set)\n".to_owned(),
|
|
|
|
s if s.ends_with('\n') => s.to_owned(),
|
|
|
|
s => format!("{s}\n"),
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct AuthorProperty;
|
|
|
|
|
2022-05-21 17:20:03 +00:00
|
|
|
impl TemplateProperty<Commit, Signature> for AuthorProperty {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> Signature {
|
|
|
|
context.author().clone()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct CommitterProperty;
|
|
|
|
|
2022-05-21 17:20:03 +00:00
|
|
|
impl TemplateProperty<Commit, Signature> for CommitterProperty {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> Signature {
|
|
|
|
context.committer().clone()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-18 21:46:12 +00:00
|
|
|
pub struct WorkingCopiesProperty<'a> {
|
2022-02-03 01:00:05 +00:00
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
2022-09-18 21:46:12 +00:00
|
|
|
impl TemplateProperty<Commit, String> for WorkingCopiesProperty<'_> {
|
2022-02-03 01:00:05 +00:00
|
|
|
fn extract(&self, context: &Commit) -> String {
|
2022-09-18 21:46:12 +00:00
|
|
|
let wc_commit_ids = self.repo.view().wc_commit_ids();
|
|
|
|
if wc_commit_ids.len() <= 1 {
|
2022-02-03 01:00:05 +00:00
|
|
|
return "".to_string();
|
|
|
|
}
|
|
|
|
let mut names = vec![];
|
2022-09-18 21:46:12 +00:00
|
|
|
for (workspace_id, wc_commit_id) in wc_commit_ids.iter().sorted() {
|
|
|
|
if wc_commit_id == context.id() {
|
2022-02-03 01:00:05 +00:00
|
|
|
names.push(format!("{}@", workspace_id.as_str()));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
names.join(" ")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-18 21:46:12 +00:00
|
|
|
pub struct IsWorkingCopyProperty<'a> {
|
2021-04-11 16:13:00 +00:00
|
|
|
pub repo: RepoRef<'a>,
|
2022-02-02 18:14:03 +00:00
|
|
|
pub workspace_id: WorkspaceId,
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2022-09-18 21:46:12 +00:00
|
|
|
impl TemplateProperty<Commit, bool> for IsWorkingCopyProperty<'_> {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> bool {
|
2022-09-18 21:46:12 +00:00
|
|
|
Some(context.id()) == self.repo.view().get_wc_commit_id(&self.workspace_id)
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-15 08:31:48 +00:00
|
|
|
pub struct BranchProperty<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, String> for BranchProperty<'_> {
|
|
|
|
fn extract(&self, context: &Commit) -> String {
|
|
|
|
let mut names = vec![];
|
|
|
|
for (branch_name, branch_target) in self.repo.view().branches() {
|
|
|
|
let local_target = branch_target.local_target.as_ref();
|
|
|
|
if let Some(local_target) = local_target {
|
|
|
|
if local_target.has_add(context.id()) {
|
|
|
|
if local_target.is_conflict() {
|
2023-01-07 01:59:57 +00:00
|
|
|
names.push(format!("{branch_name}??"));
|
2022-11-04 16:39:46 +00:00
|
|
|
} else if branch_target
|
|
|
|
.remote_targets
|
|
|
|
.values()
|
|
|
|
.any(|remote_target| remote_target != local_target)
|
|
|
|
{
|
2022-12-15 02:30:06 +00:00
|
|
|
names.push(format!("{branch_name}*"));
|
2021-07-15 08:31:48 +00:00
|
|
|
} else {
|
|
|
|
names.push(branch_name.clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
for (remote_name, remote_target) in &branch_target.remote_targets {
|
|
|
|
if Some(remote_target) != local_target && remote_target.has_add(context.id()) {
|
|
|
|
if remote_target.is_conflict() {
|
2022-12-15 02:30:06 +00:00
|
|
|
names.push(format!("{branch_name}@{remote_name}?"));
|
2021-07-15 08:31:48 +00:00
|
|
|
} else {
|
2022-12-15 02:30:06 +00:00
|
|
|
names.push(format!("{branch_name}@{remote_name}"));
|
2021-07-15 08:31:48 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
names.join(" ")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct TagProperty<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, String> for TagProperty<'_> {
|
|
|
|
fn extract(&self, context: &Commit) -> String {
|
|
|
|
let mut names = vec![];
|
|
|
|
for (tag_name, target) in self.repo.view().tags() {
|
|
|
|
if target.has_add(context.id()) {
|
|
|
|
if target.is_conflict() {
|
2022-12-15 02:30:06 +00:00
|
|
|
names.push(format!("{tag_name}?"));
|
2021-07-15 08:31:48 +00:00
|
|
|
} else {
|
|
|
|
names.push(tag_name.clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
names.join(" ")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-04-11 16:13:00 +00:00
|
|
|
pub struct GitRefsProperty<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
2021-01-03 08:26:57 +00:00
|
|
|
}
|
|
|
|
|
2021-04-11 16:13:00 +00:00
|
|
|
impl TemplateProperty<Commit, String> for GitRefsProperty<'_> {
|
2021-01-03 08:26:57 +00:00
|
|
|
fn extract(&self, context: &Commit) -> String {
|
2021-07-11 17:58:01 +00:00
|
|
|
// TODO: We should keep a map from commit to ref names so we don't have to walk
|
|
|
|
// all refs here.
|
|
|
|
let mut names = vec![];
|
|
|
|
for (name, target) in self.repo.view().git_refs() {
|
|
|
|
if target.has_add(context.id()) {
|
|
|
|
if target.is_conflict() {
|
2022-12-15 02:30:06 +00:00
|
|
|
names.push(format!("{name}?"));
|
2021-07-11 17:58:01 +00:00
|
|
|
} else {
|
|
|
|
names.push(name.clone());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
names.join(" ")
|
2021-01-03 08:26:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-29 05:33:37 +00:00
|
|
|
pub struct IsGitHeadProperty<'a> {
|
|
|
|
repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a> IsGitHeadProperty<'a> {
|
|
|
|
pub fn new(repo: RepoRef<'a>) -> Self {
|
|
|
|
Self { repo }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, bool> for IsGitHeadProperty<'_> {
|
|
|
|
fn extract(&self, context: &Commit) -> bool {
|
|
|
|
self.repo.view().git_head().as_ref() == Some(context.id())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-07 05:50:11 +00:00
|
|
|
pub struct DivergentProperty {
|
|
|
|
divergent_changes: HashSet<ChangeId>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl DivergentProperty {
|
|
|
|
pub fn new(repo: RepoRef) -> Self {
|
2021-10-07 06:05:10 +00:00
|
|
|
// TODO: Create a persistent index from change id to commit ids.
|
2021-10-07 05:50:11 +00:00
|
|
|
let mut commit_count_by_change: HashMap<ChangeId, i32> = HashMap::new();
|
2022-02-02 16:15:25 +00:00
|
|
|
for index_entry in RevsetExpression::all().evaluate(repo, None).unwrap().iter() {
|
2021-10-07 05:50:11 +00:00
|
|
|
let change_id = index_entry.change_id();
|
|
|
|
commit_count_by_change
|
|
|
|
.entry(change_id)
|
|
|
|
.or_default()
|
|
|
|
.add_assign(1);
|
|
|
|
}
|
|
|
|
let mut divergent_changes = HashSet::new();
|
|
|
|
for (change_id, count) in commit_count_by_change {
|
|
|
|
if count > 1 {
|
|
|
|
divergent_changes.insert(change_id);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Self { divergent_changes }
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2021-10-07 05:50:11 +00:00
|
|
|
impl TemplateProperty<Commit, bool> for DivergentProperty {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> bool {
|
2021-10-07 05:50:11 +00:00
|
|
|
self.divergent_changes.contains(context.change_id())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct ConflictProperty;
|
|
|
|
|
2021-01-31 07:44:31 +00:00
|
|
|
impl TemplateProperty<Commit, bool> for ConflictProperty {
|
2020-12-12 08:00:42 +00:00
|
|
|
fn extract(&self, context: &Commit) -> bool {
|
|
|
|
context.tree().has_conflict()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct ConditionalTemplate<'a, C> {
|
|
|
|
pub condition: Box<dyn TemplateProperty<C, bool> + 'a>,
|
|
|
|
pub true_template: Box<dyn Template<C> + 'a>,
|
|
|
|
pub false_template: Option<Box<dyn Template<C> + 'a>>,
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: figure out why this lifetime is needed
|
|
|
|
impl<'a, C> ConditionalTemplate<'a, C> {
|
|
|
|
pub fn new(
|
|
|
|
condition: Box<dyn TemplateProperty<C, bool> + 'a>,
|
|
|
|
true_template: Box<dyn Template<C> + 'a>,
|
|
|
|
false_template: Option<Box<dyn Template<C> + 'a>>,
|
|
|
|
) -> Self {
|
|
|
|
ConditionalTemplate {
|
|
|
|
condition,
|
|
|
|
true_template,
|
|
|
|
false_template,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C> Template<C> for ConditionalTemplate<'a, C> {
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2020-12-12 08:00:42 +00:00
|
|
|
if self.condition.extract(context) {
|
2021-06-02 22:50:08 +00:00
|
|
|
self.true_template.format(context, formatter)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
} else if let Some(false_template) = &self.false_template {
|
2021-06-02 22:50:08 +00:00
|
|
|
false_template.format(context, formatter)?;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
2021-04-07 06:05:16 +00:00
|
|
|
Ok(())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: If needed, add a ContextualTemplateFunction where the function also
|
|
|
|
// gets the context
|
|
|
|
pub struct TemplateFunction<'a, C, I, O> {
|
|
|
|
pub property: Box<dyn TemplateProperty<C, I> + 'a>,
|
|
|
|
pub function: Box<dyn Fn(I) -> O + 'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: figure out why this lifetime is needed
|
|
|
|
impl<'a, C, I, O> TemplateFunction<'a, C, I, O> {
|
|
|
|
pub fn new(
|
|
|
|
template: Box<dyn TemplateProperty<C, I> + 'a>,
|
|
|
|
function: Box<dyn Fn(I) -> O + 'a>,
|
|
|
|
) -> Self {
|
|
|
|
TemplateFunction {
|
|
|
|
property: template,
|
|
|
|
function,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<'a, C, I, O> TemplateProperty<C, O> for TemplateFunction<'a, C, I, O> {
|
|
|
|
fn extract(&self, context: &C) -> O {
|
|
|
|
(self.function)(self.property.extract(context))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-19 04:25:18 +00:00
|
|
|
/// Type-erased `CommitId`/`ChangeId`.
|
2023-01-02 23:34:54 +00:00
|
|
|
#[derive(Debug, Clone)]
|
2023-01-19 04:25:18 +00:00
|
|
|
pub struct CommitOrChangeId(Vec<u8>);
|
2023-01-02 23:34:54 +00:00
|
|
|
|
|
|
|
impl CommitOrChangeId {
|
2023-01-18 11:18:57 +00:00
|
|
|
pub fn as_bytes(&self) -> &[u8] {
|
|
|
|
&self.0
|
|
|
|
}
|
|
|
|
|
2023-01-02 23:34:54 +00:00
|
|
|
pub fn hex(&self) -> String {
|
2023-01-19 04:25:18 +00:00
|
|
|
hex::encode(&self.0)
|
2023-01-02 23:34:54 +00:00
|
|
|
}
|
|
|
|
|
2023-01-19 04:19:11 +00:00
|
|
|
pub fn short(&self) -> String {
|
2023-01-19 04:42:43 +00:00
|
|
|
let mut hex = self.hex();
|
|
|
|
hex.truncate(12);
|
|
|
|
hex
|
2023-01-02 23:34:54 +00:00
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2023-01-19 04:19:11 +00:00
|
|
|
pub fn short_prefix_and_brackets(&self, repo: RepoRef) -> String {
|
2023-01-18 11:18:57 +00:00
|
|
|
highlight_shortest_prefix(self, 12, repo)
|
2023-01-03 00:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-23 02:38:16 +00:00
|
|
|
impl Template<()> for CommitOrChangeId {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(&self.hex())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-18 11:18:57 +00:00
|
|
|
fn highlight_shortest_prefix(id: &CommitOrChangeId, total_len: usize, repo: RepoRef) -> String {
|
|
|
|
let prefix_len = repo
|
|
|
|
.base_repo()
|
|
|
|
.shortest_unique_prefix_length(id.as_bytes());
|
|
|
|
let mut hex = id.hex();
|
2023-01-19 04:48:15 +00:00
|
|
|
if prefix_len < total_len - 2 {
|
2023-01-03 00:24:00 +00:00
|
|
|
format!(
|
|
|
|
"{}[{}]",
|
|
|
|
&hex[0..prefix_len],
|
2023-01-19 04:48:15 +00:00
|
|
|
&hex[prefix_len..total_len - 2]
|
2023-01-03 00:24:00 +00:00
|
|
|
)
|
|
|
|
} else {
|
2023-01-19 04:42:43 +00:00
|
|
|
hex.truncate(total_len);
|
|
|
|
hex
|
2023-01-03 00:24:00 +00:00
|
|
|
}
|
2023-01-02 23:34:54 +00:00
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2023-01-02 23:34:54 +00:00
|
|
|
pub struct CommitOrChangeIdShort<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
2023-01-02 23:34:54 +00:00
|
|
|
|
2023-01-02 23:34:54 +00:00
|
|
|
impl TemplateProperty<CommitOrChangeId, String> for CommitOrChangeIdShort<'_> {
|
2023-01-02 23:34:54 +00:00
|
|
|
fn extract(&self, context: &CommitOrChangeId) -> String {
|
2023-01-19 04:19:11 +00:00
|
|
|
context.short()
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-03 00:24:00 +00:00
|
|
|
pub struct CommitOrChangeIdShortPrefixAndBrackets<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TemplateProperty<CommitOrChangeId, String> for CommitOrChangeIdShortPrefixAndBrackets<'_> {
|
|
|
|
fn extract(&self, context: &CommitOrChangeId) -> String {
|
2023-01-19 04:19:11 +00:00
|
|
|
context.short_prefix_and_brackets(self.repo)
|
2023-01-03 00:24:00 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-19 03:17:17 +00:00
|
|
|
pub struct CommitIdProperty;
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, CommitOrChangeId> for CommitIdProperty {
|
|
|
|
fn extract(&self, context: &Commit) -> CommitOrChangeId {
|
2023-01-19 04:25:18 +00:00
|
|
|
CommitOrChangeId(context.id().to_bytes())
|
2023-01-19 03:17:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
pub struct ChangeIdProperty;
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, CommitOrChangeId> for ChangeIdProperty {
|
2023-01-02 23:34:54 +00:00
|
|
|
fn extract(&self, context: &Commit) -> CommitOrChangeId {
|
2023-01-19 04:25:18 +00:00
|
|
|
CommitOrChangeId(context.change_id().to_bytes())
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
2022-11-26 01:33:24 +00:00
|
|
|
|
|
|
|
pub struct SignatureTimestamp;
|
|
|
|
|
|
|
|
impl TemplateProperty<Signature, Timestamp> for SignatureTimestamp {
|
|
|
|
fn extract(&self, context: &Signature) -> Timestamp {
|
|
|
|
context.timestamp.clone()
|
|
|
|
}
|
|
|
|
}
|
2023-01-14 10:43:23 +00:00
|
|
|
|
|
|
|
pub struct EmptyProperty<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TemplateProperty<Commit, bool> for EmptyProperty<'_> {
|
|
|
|
fn extract(&self, context: &Commit) -> bool {
|
|
|
|
context.tree().id() == merge_commit_trees(self.repo, &context.parents()).id()
|
|
|
|
}
|
|
|
|
}
|