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.
|
|
|
|
|
2023-01-21 23:37:01 +00:00
|
|
|
use std::cmp::{max, min};
|
2021-04-07 06:05:16 +00:00
|
|
|
use std::io;
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2021-06-09 20:57:48 +00:00
|
|
|
use itertools::Itertools;
|
2023-01-25 09:46:38 +00:00
|
|
|
use jujutsu_lib::backend::{ObjectId, Signature, Timestamp};
|
2021-05-15 16:16:31 +00:00
|
|
|
use jujutsu_lib::commit::Commit;
|
|
|
|
use jujutsu_lib::repo::RepoRef;
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2023-01-26 11:20:43 +00:00
|
|
|
use crate::formatter::{Formatter, PlainTextFormatter};
|
2023-01-31 03:48:38 +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<()>;
|
2023-02-03 04:56:56 +00:00
|
|
|
/// Returns true if `format()` will generate output other than labels.
|
|
|
|
fn has_content(&self, context: &C) -> bool;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, T: Template<C> + ?Sized> Template<C> for Box<T> {
|
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
<T as Template<C>>::format(self, context, formatter)
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
<T as Template<C>>::has_content(self, context)
|
|
|
|
}
|
2023-01-23 10:42:57 +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-23 04:11:29 +00:00
|
|
|
write!(formatter.labeled("name"), "{}", self.name)?;
|
2023-01-22 12:16:52 +00:00
|
|
|
write!(formatter, " <")?;
|
|
|
|
write!(formatter.labeled("email"), "{}", self.email)?;
|
|
|
|
write!(formatter, ">")?;
|
|
|
|
Ok(())
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
true
|
|
|
|
}
|
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)
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
!self.is_empty()
|
|
|
|
}
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for Timestamp {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(&time_util::format_absolute_timestamp(self))
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
true
|
|
|
|
}
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for bool {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(if *self { "true" } else { "false" })
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
true
|
|
|
|
}
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 11:00:52 +00:00
|
|
|
pub struct LabelTemplate<T, L> {
|
2023-01-23 10:42:57 +00:00
|
|
|
content: T,
|
2023-01-26 11:00:52 +00:00
|
|
|
labels: L,
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 11:00:52 +00:00
|
|
|
impl<T, L> LabelTemplate<T, L> {
|
|
|
|
pub fn new<C>(content: T, labels: L) -> Self
|
2023-01-23 10:42:57 +00:00
|
|
|
where
|
|
|
|
T: Template<C>,
|
2023-01-26 11:00:52 +00:00
|
|
|
L: TemplateProperty<C, Output = Vec<String>>,
|
2023-01-23 10:42:57 +00:00
|
|
|
{
|
2020-12-12 08:00:42 +00:00
|
|
|
LabelTemplate { content, labels }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-26 11:00:52 +00:00
|
|
|
impl<C, T, L> Template<C> for LabelTemplate<T, L>
|
2023-01-23 10:42:57 +00:00
|
|
|
where
|
|
|
|
T: Template<C>,
|
2023-01-26 11:00:52 +00:00
|
|
|
L: TemplateProperty<C, Output = Vec<String>>,
|
2023-01-23 10:42:57 +00:00
|
|
|
{
|
2021-06-02 22:50:08 +00:00
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
2023-01-26 11:00:52 +00:00
|
|
|
let labels = self.labels.extract(context);
|
2020-12-12 08:00:42 +00:00
|
|
|
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
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
self.content.has_content(context)
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
pub struct ListTemplate<T>(pub Vec<T>);
|
2020-12-12 08:00:42 +00:00
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, T: Template<C>> Template<C> for ListTemplate<T> {
|
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
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
self.0.iter().any(|template| template.has_content(context))
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-02-03 05:36:01 +00:00
|
|
|
/// Like `ListTemplate`, but inserts a separator between non-empty templates.
|
|
|
|
pub struct SeparateTemplate<S, T> {
|
|
|
|
separator: S,
|
|
|
|
contents: Vec<T>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<S, T> SeparateTemplate<S, T> {
|
|
|
|
pub fn new<C>(separator: S, contents: Vec<T>) -> Self
|
|
|
|
where
|
|
|
|
S: Template<C>,
|
|
|
|
T: Template<C>,
|
|
|
|
{
|
|
|
|
SeparateTemplate {
|
|
|
|
separator,
|
|
|
|
contents,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<C, S, T> Template<C> for SeparateTemplate<S, T>
|
|
|
|
where
|
|
|
|
S: Template<C>,
|
|
|
|
T: Template<C>,
|
|
|
|
{
|
|
|
|
fn format(&self, context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
// TemplateProperty may be evaluated twice, by has_content() and format().
|
|
|
|
// If that's too expensive, we can instead create a buffered formatter
|
|
|
|
// inheriting the state, and write to it to test the emptiness. In this case,
|
|
|
|
// the formatter should guarantee push/pop_label() is noop without content.
|
|
|
|
let mut content_templates = self
|
|
|
|
.contents
|
|
|
|
.iter()
|
|
|
|
.filter(|template| template.has_content(context))
|
|
|
|
.fuse();
|
|
|
|
if let Some(template) = content_templates.next() {
|
|
|
|
template.format(context, formatter)?;
|
|
|
|
}
|
|
|
|
for template in content_templates {
|
|
|
|
self.separator.format(context, formatter)?;
|
|
|
|
template.format(context, formatter)?;
|
|
|
|
}
|
|
|
|
Ok(())
|
|
|
|
}
|
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
self.contents
|
|
|
|
.iter()
|
|
|
|
.any(|template| template.has_content(context))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
pub trait TemplateProperty<C> {
|
|
|
|
type Output;
|
|
|
|
|
|
|
|
fn extract(&self, context: &C) -> Self::Output;
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, P: TemplateProperty<C> + ?Sized> TemplateProperty<C> for Box<P> {
|
|
|
|
type Output = <P as TemplateProperty<C>>::Output;
|
|
|
|
|
|
|
|
fn extract(&self, context: &C) -> Self::Output {
|
|
|
|
<P as TemplateProperty<C>>::extract(self, context)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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)
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _context: &C) -> bool {
|
|
|
|
self.0.has_content(&())
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
impl<C, O: Clone> TemplateProperty<C> for Literal<O> {
|
|
|
|
type Output = 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-29 08:46:43 +00:00
|
|
|
/// Adapter to turn closure into property.
|
|
|
|
pub struct TemplatePropertyFn<F>(pub F);
|
|
|
|
|
|
|
|
impl<C, O, F: Fn(&C) -> O> TemplateProperty<C> for TemplatePropertyFn<F> {
|
|
|
|
type Output = O;
|
|
|
|
|
|
|
|
fn extract(&self, context: &C) -> Self::Output {
|
|
|
|
(self.0)(context)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-22 23:02:46 +00:00
|
|
|
/// Adapter to extract context-less template value from property for displaying.
|
2023-01-23 10:42:57 +00:00
|
|
|
pub struct FormattablePropertyTemplate<P> {
|
|
|
|
property: P,
|
2023-01-22 23:02:46 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<P> FormattablePropertyTemplate<P> {
|
|
|
|
pub fn new<C>(property: P) -> Self
|
|
|
|
where
|
|
|
|
P: TemplateProperty<C>,
|
|
|
|
P::Output: Template<()>,
|
|
|
|
{
|
2023-01-22 23:02:46 +00:00
|
|
|
FormattablePropertyTemplate { property }
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
|
2023-01-22 23:02:46 +00:00
|
|
|
where
|
2023-01-23 10:42:57 +00:00
|
|
|
P: TemplateProperty<C>,
|
|
|
|
P::Output: Template<()>,
|
2023-01-22 23:02:46 +00:00
|
|
|
{
|
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
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
let template = self.property.extract(context);
|
|
|
|
template.has_content(&())
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-26 11:20:43 +00:00
|
|
|
/// Adapter to turn template back to string property.
|
|
|
|
pub struct PlainTextFormattedProperty<T> {
|
|
|
|
template: T,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<T> PlainTextFormattedProperty<T> {
|
|
|
|
pub fn new(template: T) -> Self {
|
|
|
|
PlainTextFormattedProperty { template }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl<C, T: Template<C>> TemplateProperty<C> for PlainTextFormattedProperty<T> {
|
|
|
|
type Output = String;
|
|
|
|
|
|
|
|
fn extract(&self, context: &C) -> Self::Output {
|
|
|
|
let mut output = vec![];
|
|
|
|
self.template
|
|
|
|
.format(context, &mut PlainTextFormatter::new(&mut output))
|
|
|
|
.expect("write() to PlainTextFormatter should never fail");
|
|
|
|
// TODO: Use from_utf8_lossy() if we added template that embeds file content
|
|
|
|
String::from_utf8(output).expect("template output should be utf-8 bytes")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-09-18 21:46:12 +00:00
|
|
|
pub struct WorkingCopiesProperty<'a> {
|
2022-02-03 01:00:05 +00:00
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
impl TemplateProperty<Commit> for WorkingCopiesProperty<'_> {
|
|
|
|
type Output = String;
|
|
|
|
|
|
|
|
fn extract(&self, context: &Commit) -> Self::Output {
|
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(" ")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-07-15 08:31:48 +00:00
|
|
|
pub struct BranchProperty<'a> {
|
|
|
|
pub repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
impl TemplateProperty<Commit> for BranchProperty<'_> {
|
|
|
|
type Output = String;
|
|
|
|
|
|
|
|
fn extract(&self, context: &Commit) -> Self::Output {
|
2021-07-15 08:31:48 +00:00
|
|
|
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>,
|
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
impl TemplateProperty<Commit> for TagProperty<'_> {
|
|
|
|
type Output = String;
|
|
|
|
|
|
|
|
fn extract(&self, context: &Commit) -> Self::Output {
|
2021-07-15 08:31:48 +00:00
|
|
|
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
|
|
|
}
|
|
|
|
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
impl TemplateProperty<Commit> for GitRefsProperty<'_> {
|
|
|
|
type Output = String;
|
|
|
|
|
|
|
|
fn extract(&self, context: &Commit) -> Self::Output {
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-17 18:17:50 +00:00
|
|
|
pub struct GitHeadProperty<'a> {
|
2021-11-29 05:33:37 +00:00
|
|
|
repo: RepoRef<'a>,
|
|
|
|
}
|
|
|
|
|
2022-12-17 18:17:50 +00:00
|
|
|
impl<'a> GitHeadProperty<'a> {
|
2021-11-29 05:33:37 +00:00
|
|
|
pub fn new(repo: RepoRef<'a>) -> Self {
|
|
|
|
Self { repo }
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-17 18:17:50 +00:00
|
|
|
impl TemplateProperty<Commit> for GitHeadProperty<'_> {
|
|
|
|
type Output = String;
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
|
2022-12-17 18:17:50 +00:00
|
|
|
fn extract(&self, context: &Commit) -> String {
|
2022-12-17 17:34:09 +00:00
|
|
|
match self.repo.view().git_head() {
|
|
|
|
Some(ref_target) if ref_target.has_add(context.id()) => {
|
|
|
|
if ref_target.is_conflict() {
|
|
|
|
"HEAD@git?".to_string()
|
|
|
|
} else {
|
|
|
|
"HEAD@git".to_string()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
_ => "".to_string(),
|
2022-12-17 18:17:50 +00:00
|
|
|
}
|
2021-11-29 05:33:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
pub struct ConditionalTemplate<P, T, U> {
|
|
|
|
pub condition: P,
|
|
|
|
pub true_template: T,
|
|
|
|
pub false_template: Option<U>,
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<P, T, U> ConditionalTemplate<P, T, U> {
|
|
|
|
pub fn new<C>(condition: P, true_template: T, false_template: Option<U>) -> Self
|
|
|
|
where
|
|
|
|
P: TemplateProperty<C, Output = bool>,
|
|
|
|
T: Template<C>,
|
|
|
|
U: Template<C>,
|
|
|
|
{
|
2020-12-12 08:00:42 +00:00
|
|
|
ConditionalTemplate {
|
|
|
|
condition,
|
|
|
|
true_template,
|
|
|
|
false_template,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, P, T, U> Template<C> for ConditionalTemplate<P, T, U>
|
|
|
|
where
|
|
|
|
P: TemplateProperty<C, Output = bool>,
|
|
|
|
T: Template<C>,
|
|
|
|
U: 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
|
|
|
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
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, context: &C) -> bool {
|
|
|
|
if self.condition.extract(context) {
|
|
|
|
self.true_template.has_content(context)
|
|
|
|
} else if let Some(false_template) = &self.false_template {
|
|
|
|
false_template.has_content(context)
|
|
|
|
} else {
|
|
|
|
false
|
|
|
|
}
|
|
|
|
}
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// TODO: If needed, add a ContextualTemplateFunction where the function also
|
|
|
|
// gets the context
|
2023-01-23 10:42:57 +00:00
|
|
|
pub struct TemplateFunction<P, F> {
|
|
|
|
pub property: P,
|
|
|
|
pub function: F,
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<P, F> TemplateFunction<P, F> {
|
2023-01-26 07:32:44 +00:00
|
|
|
pub fn new<C, O>(property: P, function: F) -> Self
|
2023-01-23 10:42:57 +00:00
|
|
|
where
|
|
|
|
P: TemplateProperty<C>,
|
|
|
|
F: Fn(P::Output) -> O,
|
|
|
|
{
|
2023-01-26 07:32:44 +00:00
|
|
|
TemplateFunction { property, function }
|
2020-12-12 08:00:42 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-23 10:42:57 +00:00
|
|
|
impl<C, O, P, F> TemplateProperty<C> for TemplateFunction<P, F>
|
|
|
|
where
|
|
|
|
P: TemplateProperty<C>,
|
|
|
|
F: Fn(P::Output) -> O,
|
|
|
|
{
|
templater: turn output parameter of TemplateProperty into associated type
When implementing FormattablePropertyTemplate, I tried a generic 'property: P'
first, and I couldn't figure out how to constrain the output type.
impl<C, O, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C, O>, // 'O' isn't constrained by type
O: Template<()>,
According to the book, the problem is that we can add multiple implementations
of 'TemplateProperty<C, *>'. Since TemplateProperty is basically a function
to extract data from 'C', I think the output parameter shouldn't be freely
chosen.
https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
With this change, I can express the type constraint as follows:
impl<C, P> Template<C> for FormattablePropertyTemplate<P>
where
P: TemplateProperty<C>,
P::Output: Template<()>,
2023-01-23 06:26:27 +00:00
|
|
|
type Output = O;
|
|
|
|
|
|
|
|
fn extract(&self, context: &C) -> Self::Output {
|
2020-12-12 08:00:42 +00:00
|
|
|
(self.function)(self.property.extract(context))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-19 04:25:18 +00:00
|
|
|
/// Type-erased `CommitId`/`ChangeId`.
|
2023-01-23 06:51:01 +00:00
|
|
|
#[derive(Clone)]
|
|
|
|
pub struct CommitOrChangeId<'a> {
|
|
|
|
repo: RepoRef<'a>,
|
|
|
|
id_bytes: Vec<u8>,
|
|
|
|
}
|
2023-01-02 23:34:54 +00:00
|
|
|
|
2023-01-31 08:56:59 +00:00
|
|
|
impl<'a> CommitOrChangeId<'a> {
|
|
|
|
pub fn new(repo: RepoRef<'a>, id: &impl ObjectId) -> Self {
|
|
|
|
CommitOrChangeId {
|
|
|
|
repo,
|
|
|
|
id_bytes: id.to_bytes(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-18 11:18:57 +00:00
|
|
|
pub fn as_bytes(&self) -> &[u8] {
|
2023-01-23 06:51:01 +00:00
|
|
|
&self.id_bytes
|
2023-01-18 11:18:57 +00:00
|
|
|
}
|
|
|
|
|
2023-01-02 23:34:54 +00:00
|
|
|
pub fn hex(&self) -> String {
|
2023-01-23 06:51:01 +00:00
|
|
|
hex::encode(&self.id_bytes)
|
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-29 08:46:43 +00:00
|
|
|
pub fn shortest_prefix_and_brackets(&self) -> String {
|
2023-01-29 02:54:34 +00:00
|
|
|
let hex = self.hex();
|
|
|
|
let (prefix, rest) = extract_entire_prefix_and_trimmed_tail(
|
|
|
|
&hex,
|
|
|
|
self.repo.shortest_unique_id_prefix_len(self.as_bytes()),
|
|
|
|
12 - 2,
|
|
|
|
);
|
|
|
|
if rest.is_empty() {
|
|
|
|
prefix.to_string()
|
|
|
|
} else {
|
|
|
|
format!("{prefix}[{rest}]")
|
|
|
|
}
|
2023-01-03 00:24:00 +00:00
|
|
|
}
|
2023-01-31 06:55:16 +00:00
|
|
|
|
|
|
|
pub fn shortest_styled_prefix(&self) -> IdWithHighlightedPrefix {
|
|
|
|
let hex = self.hex();
|
|
|
|
let (prefix, rest) = extract_entire_prefix_and_trimmed_tail(
|
|
|
|
&hex,
|
|
|
|
self.repo.shortest_unique_id_prefix_len(self.as_bytes()),
|
|
|
|
12,
|
|
|
|
);
|
|
|
|
IdWithHighlightedPrefix {
|
|
|
|
prefix: prefix.to_string(),
|
|
|
|
rest: rest.to_string(),
|
|
|
|
}
|
|
|
|
}
|
2023-01-03 00:24:00 +00:00
|
|
|
}
|
|
|
|
|
2023-01-23 06:51:01 +00:00
|
|
|
impl Template<()> for CommitOrChangeId<'_> {
|
2023-01-23 02:38:16 +00:00
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.write_str(&self.hex())
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
!self.id_bytes.is_empty()
|
|
|
|
}
|
2023-01-23 02:38:16 +00:00
|
|
|
}
|
|
|
|
|
2023-01-21 23:37:01 +00:00
|
|
|
/// This function supports short `total_len` by ensuring that the entire
|
|
|
|
/// unique prefix is always printed
|
|
|
|
fn extract_entire_prefix_and_trimmed_tail(
|
|
|
|
s: &str,
|
|
|
|
prefix_len: usize,
|
|
|
|
total_len: usize,
|
|
|
|
) -> (&str, &str) {
|
|
|
|
let prefix_len = min(prefix_len, s.len());
|
|
|
|
let total_len = max(prefix_len, min(total_len, s.len()));
|
|
|
|
(&s[0..prefix_len], &s[prefix_len..total_len])
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
|
|
|
use super::extract_entire_prefix_and_trimmed_tail;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_prefix() {
|
|
|
|
let s = "0123456789";
|
|
|
|
insta::assert_debug_snapshot!(extract_entire_prefix_and_trimmed_tail(s, 2, 5), @r###"
|
|
|
|
(
|
|
|
|
"01",
|
|
|
|
"234",
|
|
|
|
)
|
|
|
|
"###);
|
|
|
|
insta::assert_debug_snapshot!(extract_entire_prefix_and_trimmed_tail(s, 2, 11), @r###"
|
|
|
|
(
|
|
|
|
"01",
|
|
|
|
"23456789",
|
|
|
|
)
|
|
|
|
"###);
|
|
|
|
insta::assert_debug_snapshot!(extract_entire_prefix_and_trimmed_tail(s, 11, 2), @r###"
|
|
|
|
(
|
|
|
|
"0123456789",
|
|
|
|
"",
|
2023-01-03 00:24:00 +00:00
|
|
|
)
|
2023-01-21 23:37:01 +00:00
|
|
|
"###);
|
|
|
|
insta::assert_debug_snapshot!(extract_entire_prefix_and_trimmed_tail(s, 11, 11), @r###"
|
|
|
|
(
|
|
|
|
"0123456789",
|
|
|
|
"",
|
|
|
|
)
|
|
|
|
"###);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-01-31 04:41:50 +00:00
|
|
|
pub struct IdWithHighlightedPrefix {
|
|
|
|
prefix: String,
|
|
|
|
rest: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl Template<()> for IdWithHighlightedPrefix {
|
|
|
|
fn format(&self, _: &(), formatter: &mut dyn Formatter) -> io::Result<()> {
|
|
|
|
formatter.with_label("prefix", |fmt| fmt.write_str(&self.prefix))?;
|
|
|
|
formatter.with_label("rest", |fmt| fmt.write_str(&self.rest))
|
|
|
|
}
|
2023-02-03 04:56:56 +00:00
|
|
|
|
|
|
|
fn has_content(&self, _: &()) -> bool {
|
|
|
|
!self.prefix.is_empty() || !self.rest.is_empty()
|
|
|
|
}
|
2023-01-31 04:41:50 +00:00
|
|
|
}
|