mirrors/jj
1
0
Fork 1
mirror of https://github.com/martinvonz/jj.git synced 2024-10-24 15:43:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

templater: generalize Literal/Constant wrapper for any context-less template

Browse source 
Now we have 'impl Template<()> for String', 'LiteralTemplate(String)' is
a bit redundant. Let's generalize it for any 'Template<()>'. I noticed
'ConstantTemplateProperty' serves as a similar role, so unified these.
This commit is contained in:
Yuya Nishihara 2023-01-23 12:03:13 +09:00
parent 23ab89d200
commit 431395a7ee
2 changed files with 17 additions and 22 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
src/template_parser.rs
View file

@ -24,11 +24,10 @@ use crate::formatter::PlainTextFormatter;
use crate::templater::{ use crate::templater::{
AuthorProperty, BranchProperty, ChangeIdProperty, CommitIdProperty, CommitOrChangeId, AuthorProperty, BranchProperty, ChangeIdProperty, CommitIdProperty, CommitOrChangeId,
CommitOrChangeIdShort, CommitOrChangeIdShortPrefixAndBrackets, CommitterProperty, CommitOrChangeIdShort, CommitOrChangeIdShortPrefixAndBrackets, CommitterProperty,
ConditionalTemplate, ConflictProperty, ConstantTemplateProperty, DescriptionProperty, ConditionalTemplate, ConflictProperty, DescriptionProperty, DivergentProperty,
DivergentProperty, DynamicLabelTemplate, EmptyProperty, GitRefsProperty, IsGitHeadProperty, DynamicLabelTemplate, EmptyProperty, GitRefsProperty, IsGitHeadProperty, IsWorkingCopyProperty,
IsWorkingCopyProperty, LabelTemplate, ListTemplate, LiteralTemplate, SignatureTimestamp, LabelTemplate, ListTemplate, Literal, SignatureTimestamp, StringPropertyTemplate, TagProperty,
StringPropertyTemplate, TagProperty, Template, TemplateFunction, TemplateProperty, Template, TemplateFunction, TemplateProperty, WorkingCopiesProperty,
WorkingCopiesProperty,
}; };
use crate::time_util; use crate::time_util;
@ -315,7 +314,7 @@ fn parse_commit_term<'a>(
) -> Box<dyn Template<Commit> + 'a> { ) -> Box<dyn Template<Commit> + 'a> {
assert_eq!(pair.as_rule(), Rule::term); assert_eq!(pair.as_rule(), Rule::term);
if pair.as_str().is_empty() { if pair.as_str().is_empty() {
Box::new(LiteralTemplate(String::new())) Box::new(Literal(String::new()))
} else { } else {
let mut inner = pair.into_inner(); let mut inner = pair.into_inner();
let expr = inner.next().unwrap(); let expr = inner.next().unwrap();
@ -325,10 +324,9 @@ fn parse_commit_term<'a>(
Rule::literal => { Rule::literal => {
let text = parse_string_literal(expr); let text = parse_string_literal(expr);
if maybe_method.as_str().is_empty() { if maybe_method.as_str().is_empty() {
Box::new(LiteralTemplate(text)) Box::new(Literal(text))
} else { } else {
let input_property = let input_property = Property::String(Box::new(Literal(text)));
Property::String(Box::new(ConstantTemplateProperty { output: text }));
let PropertyAndLabels(property, method_labels) = let PropertyAndLabels(property, method_labels) =
parse_method_chain(maybe_method, input_property); parse_method_chain(maybe_method, input_property);
let string_property = coerce_to_string(property); let string_property = coerce_to_string(property);
@ -437,7 +435,7 @@ fn parse_commit_template_rule<'a>(
} }
Box::new(ListTemplate(formatters)) Box::new(ListTemplate(formatters))
} }
_ => Box::new(LiteralTemplate(String::new())), _ => Box::new(Literal(String::new())),
} }
} }

21
src/templater.rs
View file

@ -55,14 +55,6 @@ impl Template<()> for bool {
} }
} }
pub struct LiteralTemplate(pub String);
impl<C> Template<C> for LiteralTemplate {
fn format(&self, _context: &C, formatter: &mut dyn Formatter) -> io::Result<()> {
formatter.write_str(&self.0)
}
}
// TODO: figure out why this lifetime is needed // TODO: figure out why this lifetime is needed
pub struct LabelTemplate<'a, C> { pub struct LabelTemplate<'a, C> {
content: Box<dyn Template<C> + 'a>, content: Box<dyn Template<C> + 'a>,
@ -138,13 +130,18 @@ pub trait TemplateProperty<C, O> {
fn extract(&self, context: &C) -> O; fn extract(&self, context: &C) -> O;
} }
pub struct ConstantTemplateProperty<O> { /// Adapter to drop template context.
pub output: O, 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)
}
} }
impl<C, O: Clone> TemplateProperty<C, O> for ConstantTemplateProperty<O> { impl<C, O: Clone> TemplateProperty<C, O> for Literal<O> {
fn extract(&self, _context: &C) -> O { fn extract(&self, _context: &C) -> O {
self.output.clone() self.0.clone()
} }
} }