mirrors/jj
1
0
Fork 1
mirror of https://github.com/martinvonz/jj.git synced 2024-12-04 05:28:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 12
jj/tests/test_templater.rs

662 lines
22 KiB
Rust
Raw Normal View History

copyright: change from "Google LLC" to "The Jujutsu Authors" Let's acknowledge everyone's contributions by replacing "Google LLC" in the copyright header by "The Jujutsu Authors". If I understand correctly, it won't have any legal effect, but maybe it still helps reduce concerns from contributors (though I haven't heard any concerns). Google employees can read about Google's policy at go/releasing/contributions#copyright.
2022-11-26 23:57:50 +00:00
// Copyright 2022 The Jujutsu Authors
templater: indicate if branch needs to be pushed to a remote It's useful to know when you've modified a branch that exists on a remote. A typical case is when you have pushed a branch to a remote and then rewritten it. This commit adds an indication in the `branches` template keyword. A branch that needs to be pushed to a remote now has a `*` at the end (similar to how conflicted branches have a `?` at the end). Note that the indication only considers remotes where the branch currently exists, so there won't be an indication that the branch has not been pushed to a remote. Closes #254
2022-11-04 16:39:46 +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.
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
use std::path::Path;
cli: load [template-aliases] section and pass around aliases table
2023-02-12 08:53:09 +00:00
use crate::common::{get_stderr_string, get_stdout_string, TestEnvironment};
templater: indicate if branch needs to be pushed to a remote It's useful to know when you've modified a branch that exists on a remote. A typical case is when you have pushed a branch to a remote and then rewritten it. This commit adds an indication in the `branches` template keyword. A branch that needs to be pushed to a remote now has a `*` at the end (similar to how conflicted branches have a `?` at the end). Note that the indication only considers remotes where the branch currently exists, so there won't be an indication that the branch has not been pushed to a remote. Closes #254
2022-11-04 16:39:46 +00:00
pub mod common;
#[test]
fn test_templater_branches() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "--git", "origin"]);
let origin_path = test_env.env_root().join("origin");
let origin_git_repo_path = origin_path
.join(".jj")
.join("repo")
.join("store")
.join("git");
// Created some branches on the remote
test_env.jj_cmd_success(&origin_path, &["describe", "-m=description 1"]);
test_env.jj_cmd_success(&origin_path, &["branch", "create", "branch1"]);
test_env.jj_cmd_success(&origin_path, &["new", "root", "-m=description 2"]);
test_env.jj_cmd_success(&origin_path, &["branch", "create", "branch2"]);
test_env.jj_cmd_success(&origin_path, &["new", "root", "-m=description 3"]);
test_env.jj_cmd_success(&origin_path, &["branch", "create", "branch3"]);
test_env.jj_cmd_success(&origin_path, &["git", "export"]);
test_env.jj_cmd_success(
test_env.env_root(),
&[
"git",
"clone",
origin_git_repo_path.to_str().unwrap(),
"local",
],
);
let workspace_root = test_env.env_root().join("local");
// Rewrite branch1, move branch2 forward, create conflict in branch3, add
// new-branch
test_env.jj_cmd_success(
&workspace_root,
&["describe", "branch1", "-m", "modified branch1 commit"],
);
test_env.jj_cmd_success(&workspace_root, &["new", "branch2"]);
test_env.jj_cmd_success(&workspace_root, &["branch", "set", "branch2"]);
test_env.jj_cmd_success(&workspace_root, &["branch", "create", "new-branch"]);
test_env.jj_cmd_success(&workspace_root, &["describe", "branch3", "-m=local"]);
test_env.jj_cmd_success(&origin_path, &["describe", "branch3", "-m=origin"]);
test_env.jj_cmd_success(&origin_path, &["git", "export"]);
test_env.jj_cmd_success(&workspace_root, &["git", "fetch"]);
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
let template = r#"commit_id.short() ++ " " ++ branches"#;
tests: extract log template function/variable for code readability Also rewrites some lengthy templates. That's why the test output slightly changed.
2023-02-28 10:43:14 +00:00
let output = test_env.jj_cmd_success(&workspace_root, &["log", "-T", template]);
templater: indicate if branch needs to be pushed to a remote It's useful to know when you've modified a branch that exists on a remote. A typical case is when you have pushed a branch to a remote and then rewritten it. This commit adds an indication in the `branches` template keyword. A branch that needs to be pushed to a remote now has a `*` at the end (similar to how conflicted branches have a `?` at the end). Note that the indication only considers remotes where the branch currently exists, so there won't be an indication that the branch has not been pushed to a remote. Closes #254
2022-11-04 16:39:46 +00:00
insta::assert_snapshot!(output, @r###"
cli: switch default graph style to be Sapling's curved style We seem to quite unanimously prefer this style, so let's make the default.
2023-02-09 02:53:47 +00:00
o b1bb3766d584 branch3??
│ @ a5b4d15489cc branch2* new-branch
│ │ o 21c33875443e branch1*
├───╯
│ o 8476341eb395 branch2@origin
├─╯
o 000000000000
templater: indicate if branch needs to be pushed to a remote It's useful to know when you've modified a branch that exists on a remote. A typical case is when you have pushed a branch to a remote and then rewritten it. This commit adds an indication in the `branches` template keyword. A branch that needs to be pushed to a remote now has a `*` at the end (similar to how conflicted branches have a `?` at the end). Note that the indication only considers remotes where the branch currently exists, so there won't be an indication that the branch has not been pushed to a remote. Closes #254
2022-11-04 16:39:46 +00:00
"###);
}
templater: fix parsing of parenthesized expression A "list" is a sequence of more than one "term" nodes, so it shouldn't contain a single parenthesized node. Also, a parenthesized "term" rule wasn't handled.
2023-01-28 10:23:39 +00:00
#[test]
fn test_templater_parsed_tree() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
let render = |template| get_template_output(&test_env, &repo_path, "@-", template);
templater: fix parsing of parenthesized expression A "list" is a sequence of more than one "term" nodes, so it shouldn't contain a single parenthesized node. Also, a parenthesized "term" rule wasn't handled.
2023-01-28 10:23:39 +00:00
templater: move epsilon rule out of term rule Suppose "template" is a sequence of "term"s, it makes more sense to handle an empty sequence there. It might be even better to disallow empty template other than the top-level one.
2023-01-28 11:09:13 +00:00
// Empty
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
insta::assert_snapshot!(render(r#" "#), @"");
templater: move epsilon rule out of term rule Suppose "template" is a sequence of "term"s, it makes more sense to handle an empty sequence there. It might be even better to disallow empty template other than the top-level one.
2023-01-28 11:09:13 +00:00
// Single term with whitespace
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
insta::assert_snapshot!(render(r#" commit_id.short() "#), @"000000000000");
templater: move epsilon rule out of term rule Suppose "template" is a sequence of "term"s, it makes more sense to handle an empty sequence there. It might be even better to disallow empty template other than the top-level one.
2023-01-28 11:09:13 +00:00
// Multiple terms
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render(r#" commit_id.short() ++ empty "#), @"000000000000true");
templater: move epsilon rule out of term rule Suppose "template" is a sequence of "term"s, it makes more sense to handle an empty sequence there. It might be even better to disallow empty template other than the top-level one.
2023-01-28 11:09:13 +00:00
templater: fix parsing of parenthesized expression A "list" is a sequence of more than one "term" nodes, so it shouldn't contain a single parenthesized node. Also, a parenthesized "term" rule wasn't handled.
2023-01-28 10:23:39 +00:00
// Parenthesized single term
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
insta::assert_snapshot!(render(r#"(commit_id.short())"#), @"000000000000");
templater: fix parsing of parenthesized expression A "list" is a sequence of more than one "term" nodes, so it shouldn't contain a single parenthesized node. Also, a parenthesized "term" rule wasn't handled.
2023-01-28 10:23:39 +00:00
// Parenthesized multiple terms and concatenation
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render(r#"(commit_id.short() ++ " ") ++ empty"#), @"000000000000 true");
templater: reuse parse_commit_term() to coerce if() condition to bool This should fix some inconsistent parsing of condition term.
2023-01-29 03:15:17 +00:00
// Parenthesized "if" condition
insta::assert_snapshot!(render(r#"if((divergent), "t", "f")"#), @"f");
templater: fix handling of method chaining of parenthesized expression
2023-02-04 12:10:18 +00:00
// Parenthesized method chaining
insta::assert_snapshot!(render(r#"(commit_id).short()"#), @"000000000000");
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
}
templater: report syntax error, don't panic() Even though the template syntax is experimental, panicking parser makes it difficult to write tests. So let's add minimal error handling. The error types are basically copied from the revset module. I made write_commit_summary() fall back to the default template if user template had syntax error. It should be better than reporting parse error after e.g. "jj abandon" finished successfully.
2023-02-02 08:57:55 +00:00
#[test]
fn test_templater_parse_error() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render_err = |template| test_env.jj_cmd_failure(&repo_path, &["log", "-T", template]);
insta::assert_snapshot!(render_err(r#"description ()"#), @r###"
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
Error: Failed to parse template: --> 1:13
templater: report syntax error, don't panic() Even though the template syntax is experimental, panicking parser makes it difficult to write tests. So let's add minimal error handling. The error types are basically copied from the revset module. I made write_commit_summary() fall back to the default template if user template had syntax error. It should be better than reporting parse error after e.g. "jj abandon" finished successfully.
2023-02-02 08:57:55 +00:00
|
1 | description ()
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
| ^---
templater: report syntax error, don't panic() Even though the template syntax is experimental, panicking parser makes it difficult to write tests. So let's add minimal error handling. The error types are basically copied from the revset module. I made write_commit_summary() fall back to the default template if user template had syntax error. It should be better than reporting parse error after e.g. "jj abandon" finished successfully.
2023-02-02 08:57:55 +00:00
|
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
= expected EOI
templater: report syntax error, don't panic() Even though the template syntax is experimental, panicking parser makes it difficult to write tests. So let's add minimal error handling. The error types are basically copied from the revset module. I made write_commit_summary() fall back to the default template if user template had syntax error. It should be better than reporting parse error after e.g. "jj abandon" finished successfully.
2023-02-02 08:57:55 +00:00
"###);
templater: report keyword/function/method name error
2023-02-02 10:31:50 +00:00
insta::assert_snapshot!(render_err(r#"foo"#), @r###"
Error: Failed to parse template: --> 1:1
|
1 | foo
| ^-^
|
= Keyword "foo" doesn't exist
"###);
insta::assert_snapshot!(render_err(r#"foo()"#), @r###"
Error: Failed to parse template: --> 1:1
|
1 | foo()
| ^-^
|
= Function "foo" doesn't exist
"###);
insta::assert_snapshot!(render_err(r#"description.first_line().foo()"#), @r###"
Error: Failed to parse template: --> 1:26
|
1 | description.first_line().foo()
| ^-^
|
= Method "foo" doesn't exist for type "String"
"###);
templater: check number of method arguments
2023-02-04 08:26:00 +00:00
templater: add parsing rule for integer literal, add i64 property This will be used as a parameter of id.shortest*() methods. For now, only decimal literal is supported, and there's no unary negate operator. "0"-prefix is disallowed because it looks like an octal number. I don't think we would want multiple integer types in the template language, so I chose i64 as the integer type of reasonable width.
2023-02-04 12:36:11 +00:00
insta::assert_snapshot!(render_err(r#"10000000000000000000"#), @r###"
Error: Failed to parse template: --> 1:1
|
1 | 10000000000000000000
| ^------------------^
|
= Invalid integer literal: number too large to fit in target type
"###);
insta::assert_snapshot!(render_err(r#"42.foo()"#), @r###"
Error: Failed to parse template: --> 1:4
|
1 | 42.foo()
| ^-^
|
= Method "foo" doesn't exist for type "Integer"
"###);
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render_err(r#"("foo" ++ "bar").baz()"#), @r###"
Error: Failed to parse template: --> 1:18
templater: fix handling of method chaining of parenthesized expression
2023-02-04 12:10:18 +00:00
|
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
1 | ("foo" ++ "bar").baz()
| ^-^
templater: fix handling of method chaining of parenthesized expression
2023-02-04 12:10:18 +00:00
|
= Method "baz" doesn't exist for type "Template"
"###);
templater: implement string.contains() method as example
2023-02-04 07:38:39 +00:00
insta::assert_snapshot!(render_err(r#"description.contains()"#), @r###"
Error: Failed to parse template: --> 1:22
|
1 | description.contains()
| ^
|
= Expected 1 arguments
"###);
templater: check number of method arguments
2023-02-04 08:26:00 +00:00
insta::assert_snapshot!(render_err(r#"description.first_line("foo")"#), @r###"
Error: Failed to parse template: --> 1:24
|
1 | description.first_line("foo")
| ^---^
|
= Expected 0 arguments
"###);
templater: report invalid argument type as error
2023-02-02 11:13:12 +00:00
templater: report invalid argument count as error We'll probably need a helper to extract N..M arguments, but let's revisit it later.
2023-02-02 11:21:00 +00:00
insta::assert_snapshot!(render_err(r#"label()"#), @r###"
Error: Failed to parse template: --> 1:7
|
1 | label()
| ^
|
= Expected 2 arguments
"###);
insta::assert_snapshot!(render_err(r#"label("foo", "bar", "baz")"#), @r###"
Error: Failed to parse template: --> 1:7
|
1 | label("foo", "bar", "baz")
| ^-----------------^
|
= Expected 2 arguments
"###);
insta::assert_snapshot!(render_err(r#"if()"#), @r###"
Error: Failed to parse template: --> 1:4
|
1 | if()
| ^
|
= Expected 2 to 3 arguments
"###);
insta::assert_snapshot!(render_err(r#"if("foo", "bar", "baz", "quux")"#), @r###"
Error: Failed to parse template: --> 1:4
|
1 | if("foo", "bar", "baz", "quux")
| ^-------------------------^
|
= Expected 2 to 3 arguments
"###);
templater: report invalid argument type as error
2023-02-02 11:13:12 +00:00
insta::assert_snapshot!(render_err(r#"if(label("foo", "bar"), "baz")"#), @r###"
Error: Failed to parse template: --> 1:4
|
1 | if(label("foo", "bar"), "baz")
| ^-----------------^
|
= Expected argument of type "Boolean"
"###);
templater: report syntax error, don't panic() Even though the template syntax is experimental, panicking parser makes it difficult to write tests. So let's add minimal error handling. The error types are basically copied from the revset module. I made write_commit_summary() fall back to the default template if user template had syntax error. It should be better than reporting parse error after e.g. "jj abandon" finished successfully.
2023-02-02 08:57:55 +00:00
}
templater: fix crash on "".first_line()
2023-01-31 09:49:28 +00:00
#[test]
fn test_templater_string_method() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
templater: implement string.contains() method as example
2023-02-04 07:38:39 +00:00
test_env.jj_cmd_success(&repo_path, &["commit", "-m=description 1"]);
templater: fix crash on "".first_line()
2023-01-31 09:49:28 +00:00
let render = |template| get_template_output(&test_env, &repo_path, "@-", template);
templater: implement string.contains() method as example
2023-02-04 07:38:39 +00:00
insta::assert_snapshot!(render(r#""fooo".contains("foo")"#), @"true");
insta::assert_snapshot!(render(r#""foo".contains("fooo")"#), @"false");
insta::assert_snapshot!(render(r#"description.contains("description")"#), @"true");
insta::assert_snapshot!(
render(r#""description 123".contains(description.first_line())"#), @"true");
templater: fix crash on "".first_line()
2023-01-31 09:49:28 +00:00
insta::assert_snapshot!(render(r#""".first_line()"#), @"");
insta::assert_snapshot!(render(r#""foo\nbar".first_line()"#), @"foo");
templater: add string.lines() method This wouldn't be used much in practice, but is useful for writing tests of list methods.
2023-03-07 09:19:50 +00:00
insta::assert_snapshot!(render(r#""".lines()"#), @"");
insta::assert_snapshot!(render(r#""a\nb\nc\n".lines()"#), @"a b c");
templater: fix crash on "".first_line()
2023-01-31 09:49:28 +00:00
}
`author`/`committer` templates: add a `username` method I haven't used a proper email address parser as I'm not really sure if it's worth the extra dependency and effort -- thoughts?
2023-02-10 17:01:28 +00:00
#[test]
fn test_templater_signature() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_template_output(&test_env, &repo_path, "@", template);
test_env.jj_cmd_success(&repo_path, &["new"]);
insta::assert_snapshot!(render(r#"author"#), @"Test User <test.user@example.com>");
insta::assert_snapshot!(render(r#"author.name()"#), @"Test User");
insta::assert_snapshot!(render(r#"author.email()"#), @"test.user@example.com");
insta::assert_snapshot!(render(r#"author.username()"#), @"test.user");
test_env.jj_cmd_success(
&repo_path,
&["--config-toml=user.name='Another Test User'", "new"],
);
insta::assert_snapshot!(render(r#"author"#), @"Another Test User <test.user@example.com>");
insta::assert_snapshot!(render(r#"author.name()"#), @"Another Test User");
insta::assert_snapshot!(render(r#"author.email()"#), @"test.user@example.com");
insta::assert_snapshot!(render(r#"author.username()"#), @"test.user");
test_env.jj_cmd_success(
&repo_path,
&[
"--config-toml=user.email='test.user@invalid@example.com'",
"new",
],
);
insta::assert_snapshot!(render(r#"author"#), @"Test User <test.user@invalid@example.com>");
insta::assert_snapshot!(render(r#"author.name()"#), @"Test User");
insta::assert_snapshot!(render(r#"author.email()"#), @"test.user@invalid@example.com");
insta::assert_snapshot!(render(r#"author.username()"#), @"test.user");
test_env.jj_cmd_success(&repo_path, &["--config-toml=user.email='test.user'", "new"]);
insta::assert_snapshot!(render(r#"author"#), @"Test User <test.user>");
insta::assert_snapshot!(render(r#"author.email()"#), @"test.user");
insta::assert_snapshot!(render(r#"author.username()"#), @"test.user");
test_env.jj_cmd_success(
&repo_path,
&[
"--config-toml=user.email='test.user+tag@example.com'",
"new",
],
);
insta::assert_snapshot!(render(r#"author"#), @"Test User <test.user+tag@example.com>");
insta::assert_snapshot!(render(r#"author.email()"#), @"test.user+tag@example.com");
insta::assert_snapshot!(render(r#"author.username()"#), @"test.user+tag");
test_env.jj_cmd_success(&repo_path, &["--config-toml=user.email='x@y'", "new"]);
insta::assert_snapshot!(render(r#"author"#), @"Test User <x@y>");
insta::assert_snapshot!(render(r#"author.email()"#), @"x@y");
insta::assert_snapshot!(render(r#"author.username()"#), @"x");
}
templater: add indent(prefix, content) function The argument order is different from Mercurial's indent() function. I think indent(prefix, content) is more readable for lengthy content. However, indent(content, prefix, ...) might be better if we want to add an optional firstline_prefix argument.
2023-03-02 08:16:22 +00:00
#[test]
fn test_templater_indent_function() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_colored_template_output(&test_env, &repo_path, "@-", template);
// Empty line shouldn't be indented. Not using insta here because we test
// whitespace existence.
assert_eq!(render(r#"indent("__", "")"#), "");
assert_eq!(render(r#"indent("__", "\n")"#), "\n");
assert_eq!(render(r#"indent("__", "a\n\nb")"#), "__a\n\n__b");
// "\n" at end of labeled text
insta::assert_snapshot!(
render(r#"indent("__", label("error", "a\n") ++ label("warning", "b\n"))"#),
@r###"
__a
__b
"###);
// "\n" in labeled text
insta::assert_snapshot!(
render(r#"indent("__", label("error", "a") ++ label("warning", "b\nc"))"#),
@r###"
__ab
__c
"###);
// Labeled prefix + unlabeled content
insta::assert_snapshot!(
render(r#"indent(label("error", "XX"), "a\nb\n")"#),
@r###"
XXa
XXb
"###);
// Nested indent, silly but works
insta::assert_snapshot!(
render(r#"indent(label("hint", "A"),
label("warning", indent(label("hint", "B"),
label("error", "x\n") ++ "y")))"#),
@r###"
ABx
ABy
"###);
}
templater: add wrapper that turns template back to string property I have no idea whether or not any template expressions are intentionally allowed as a label, but it makes sense to write something like 'label("phase-" phase, ...)' (if we had a phase keyword.) So I decided to add .into_plain_text() instead of stricter .try_into_string().
2023-01-26 11:20:43 +00:00
#[test]
fn test_templater_label_function() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
tests: extract helper that renders colored commit template
2023-02-03 13:13:56 +00:00
let render = |template| get_colored_template_output(&test_env, &repo_path, "@-", template);
templater: add wrapper that turns template back to string property I have no idea whether or not any template expressions are intentionally allowed as a label, but it makes sense to write something like 'label("phase-" phase, ...)' (if we had a phase keyword.) So I decided to add .into_plain_text() instead of stricter .try_into_string().
2023-01-26 11:20:43 +00:00
// Literal
insta::assert_snapshot!(render(r#"label("error", "text")"#), @"text");
// Evaluated property
insta::assert_snapshot!(
render(r#"label("error".first_line(), "text")"#), @"text");
// Template
insta::assert_snapshot!(
render(r#"label(if(empty, "error", "warning"), "text")"#), @"text");
}
templater: add concat(contents..) function, migrate default templates Multi-line templates looked a bit ugly if I replaced all implicit concats with ++ operations.
2023-02-09 10:46:55 +00:00
#[test]
fn test_templater_concat_function() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_colored_template_output(&test_env, &repo_path, "@-", template);
insta::assert_snapshot!(render(r#"concat()"#), @"");
insta::assert_snapshot!(render(r#"concat(author, empty)"#), @" <>true");
insta::assert_snapshot!(
render(r#"concat(label("error", ""), label("warning", "a"), "b")"#),
@"ab");
}
templater: add separate(sep, contents...) function This is a copy of Mercurial's separate() function.
2023-02-03 05:36:01 +00:00
#[test]
fn test_templater_separate_function() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_colored_template_output(&test_env, &repo_path, "@-", template);
insta::assert_snapshot!(render(r#"separate(" ")"#), @"");
insta::assert_snapshot!(render(r#"separate(" ", "")"#), @"");
insta::assert_snapshot!(render(r#"separate(" ", "a")"#), @"a");
insta::assert_snapshot!(render(r#"separate(" ", "a", "b")"#), @"a b");
insta::assert_snapshot!(render(r#"separate(" ", "a", "", "b")"#), @"a b");
insta::assert_snapshot!(render(r#"separate(" ", "a", "b", "")"#), @"a b");
insta::assert_snapshot!(render(r#"separate(" ", "", "a", "b")"#), @"a b");
// Labeled
insta::assert_snapshot!(
render(r#"separate(" ", label("error", ""), label("warning", "a"), "b")"#),
@"a b");
// List template
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render(r#"separate(" ", "a", ("" ++ ""))"#), @"a");
insta::assert_snapshot!(render(r#"separate(" ", "a", ("" ++ "b"))"#), @"a b");
templater: add separate(sep, contents...) function This is a copy of Mercurial's separate() function.
2023-02-03 05:36:01 +00:00
// Nested separate
insta::assert_snapshot!(
render(r#"separate(" ", "a", separate("|", "", ""))"#), @"a");
insta::assert_snapshot!(
render(r#"separate(" ", "a", separate("|", "b", ""))"#), @"a b");
insta::assert_snapshot!(
render(r#"separate(" ", "a", separate("|", "b", "c"))"#), @"a b|c");
// Conditional template
insta::assert_snapshot!(
render(r#"separate(" ", "a", if("t", ""))"#), @"a");
insta::assert_snapshot!(
render(r#"separate(" ", "a", if("t", "", "f"))"#), @"a");
insta::assert_snapshot!(
render(r#"separate(" ", "a", if("", "t", ""))"#), @"a");
insta::assert_snapshot!(
render(r#"separate(" ", "a", if("t", "t", "f"))"#), @"a t");
// Separate keywords
insta::assert_snapshot!(
render(r#"separate(" ", author, description, empty)"#), @" <> true");
// Keyword as separator
insta::assert_snapshot!(
render(r#"separate(author, "X", "Y", "Z")"#), @"X <>Y <>Z");
}
templater: Upper and lowercase ids and strings
2023-02-21 04:38:52 +00:00
#[test]
fn test_templater_upper_lower() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_colored_template_output(&test_env, &repo_path, "@-", template);
insta::assert_snapshot!(
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
render(r#"change_id.shortest(4).upper() ++ change_id.shortest(4).upper().lower()"#),
templater: Upper and lowercase ids and strings
2023-02-21 04:38:52 +00:00
@"ZZZZzzzz");
insta::assert_snapshot!(
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
render(r#""Hello".upper() ++ "Hello".lower()"#), @"HELLOhello");
templater: Upper and lowercase ids and strings
2023-02-21 04:38:52 +00:00
}
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
#[test]
fn test_templater_alias() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
let render = |template| get_template_output(&test_env, &repo_path, "@-", template);
let render_err = |template| test_env.jj_cmd_failure(&repo_path, &["log", "-T", template]);
test_env.add_config(
r###"
[template-aliases]
'my_commit_id' = 'commit_id.short()'
'syntax_error' = 'foo.'
'name_error' = 'unknown_id'
'recurse' = 'recurse1'
'recurse1' = 'recurse2()'
'recurse2()' = 'recurse'
'identity(x)' = 'x'
'coalesce(x, y)' = 'if(x, x, y)'
"###,
);
insta::assert_snapshot!(render("my_commit_id"), @"000000000000");
insta::assert_snapshot!(render("identity(my_commit_id)"), @"000000000000");
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render_err("commit_id ++ syntax_error"), @r###"
Error: Failed to parse template: --> 1:14
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
1 | commit_id ++ syntax_error
| ^----------^
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
= Alias "syntax_error" cannot be expanded
--> 1:5
|
1 | foo.
| ^---
|
= expected identifier
"###);
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render_err("commit_id ++ name_error"), @r###"
Error: Failed to parse template: --> 1:14
templater: save alias chain to report type/name error in original context Since type/name checking is made after alias substitution, we need to preserve the original context to generate a readable error message. We could instead attach a stack of (alias_id, span) to ExpressionNode, but the extra AliasExpanded node helps to capture downstream error by a single .map_err() call.
2023-02-12 12:44:33 +00:00
|
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
1 | commit_id ++ name_error
| ^--------^
templater: save alias chain to report type/name error in original context Since type/name checking is made after alias substitution, we need to preserve the original context to generate a readable error message. We could instead attach a stack of (alias_id, span) to ExpressionNode, but the extra AliasExpanded node helps to capture downstream error by a single .map_err() call.
2023-02-12 12:44:33 +00:00
|
= Alias "name_error" cannot be expanded
--> 1:1
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
1 | unknown_id
| ^--------^
|
= Keyword "unknown_id" doesn't exist
"###);
templater: save alias chain to report type/name error in original context Since type/name checking is made after alias substitution, we need to preserve the original context to generate a readable error message. We could instead attach a stack of (alias_id, span) to ExpressionNode, but the extra AliasExpanded node helps to capture downstream error by a single .map_err() call.
2023-02-12 12:44:33 +00:00
insta::assert_snapshot!(render_err(r#"identity(identity(commit_id.short("")))"#), @r###"
Error: Failed to parse template: --> 1:1
|
1 | identity(identity(commit_id.short("")))
| ^-------------------------------------^
|
= Alias "identity()" cannot be expanded
--> 1:10
|
1 | identity(identity(commit_id.short("")))
| ^---------------------------^
|
= Alias "identity()" cannot be expanded
--> 1:35
|
1 | identity(identity(commit_id.short("")))
| ^^
|
= Expected argument of type "Integer"
"###);
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
insta::assert_snapshot!(render_err("commit_id ++ recurse"), @r###"
Error: Failed to parse template: --> 1:14
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
templater: require infix ++ operator to concatenate expressions This eliminates ambiguous parsing between "func()" and "expr ()". I chose "++" as template concatenation operator in case we want to add bit-wise negate operator. It's also easier to find/replace than "~".
2023-02-28 11:30:57 +00:00
1 | commit_id ++ recurse
| ^-----^
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
= Alias "recurse" cannot be expanded
--> 1:1
|
1 | recurse1
| ^------^
|
= Alias "recurse1" cannot be expanded
--> 1:1
|
1 | recurse2()
| ^--------^
|
= Alias "recurse2()" cannot be expanded
--> 1:1
|
1 | recurse
| ^-----^
|
= Alias "recurse" expanded recursively
"###);
insta::assert_snapshot!(render_err("identity()"), @r###"
Error: Failed to parse template: --> 1:10
|
1 | identity()
| ^
|
= Expected 1 arguments
"###);
insta::assert_snapshot!(render_err("identity(commit_id, commit_id)"), @r###"
Error: Failed to parse template: --> 1:10
|
1 | identity(commit_id, commit_id)
| ^------------------^
|
= Expected 1 arguments
"###);
insta::assert_snapshot!(render_err(r#"coalesce(label("x", "not boolean"), "")"#), @r###"
templater: save alias chain to report type/name error in original context Since type/name checking is made after alias substitution, we need to preserve the original context to generate a readable error message. We could instead attach a stack of (alias_id, span) to ExpressionNode, but the extra AliasExpanded node helps to capture downstream error by a single .map_err() call.
2023-02-12 12:44:33 +00:00
Error: Failed to parse template: --> 1:1
|
1 | coalesce(label("x", "not boolean"), "")
| ^-------------------------------------^
|
= Alias "coalesce()" cannot be expanded
--> 1:10
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
|
1 | coalesce(label("x", "not boolean"), "")
| ^-----------------------^
|
= Expected argument of type "Boolean"
"###);
}
cli: load [template-aliases] section and pass around aliases table
2023-02-12 08:53:09 +00:00
#[test]
fn test_templater_bad_alias_decl() {
let test_env = TestEnvironment::default();
test_env.jj_cmd_success(test_env.env_root(), &["init", "repo", "--git"]);
let repo_path = test_env.env_root().join("repo");
test_env.add_config(
r###"
[template-aliases]
'badfn(a, a)' = 'a'
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
'my_commit_id' = 'commit_id.short()'
cli: load [template-aliases] section and pass around aliases table
2023-02-12 08:53:09 +00:00
"###,
);
// Invalid declaration should be warned and ignored.
let assert = test_env
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
.jj_cmd(&repo_path, &["log", "--no-graph", "-r@-", "-Tmy_commit_id"])
cli: load [template-aliases] section and pass around aliases table
2023-02-12 08:53:09 +00:00
.assert()
.success();
templater: implement symbol/function alias expansion Test vectors are mainly copied from revset.rs and adapted to the template syntax. Closes #1190
2023-02-12 09:41:53 +00:00
insta::assert_snapshot!(get_stdout_string(&assert), @"000000000000");
cli: load [template-aliases] section and pass around aliases table
2023-02-12 08:53:09 +00:00
insta::assert_snapshot!(get_stderr_string(&assert), @r###"
Failed to load "template-aliases.badfn(a, a)": --> 1:7
|
1 | badfn(a, a)
| ^--^
|
= Redefinition of function parameter
"###);
}
tests: extract helper that renders single commit template with no graph
2023-01-31 09:41:15 +00:00
fn get_template_output(
test_env: &TestEnvironment,
repo_path: &Path,
rev: &str,
template: &str,
) -> String {
test_env.jj_cmd_success(repo_path, &["log", "--no-graph", "-r", rev, "-T", template])
templater: fix parsing of parenthesized expression A "list" is a sequence of more than one "term" nodes, so it shouldn't contain a single parenthesized node. Also, a parenthesized "term" rule wasn't handled.
2023-01-28 10:23:39 +00:00
}
tests: extract helper that renders colored commit template
2023-02-03 13:13:56 +00:00
fn get_colored_template_output(
test_env: &TestEnvironment,
repo_path: &Path,
rev: &str,
template: &str,
) -> String {
test_env.jj_cmd_success(
repo_path,
&[
"log",
"--color=always",
"--no-graph",
"-r",
rev,
"-T",
template,
],
)
}
Reference in a new issue Copy permalink