This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12392

merge-lists: make it possible to specify pattern to match
ClosedPublic

Authored by martinvonz on Tue, Mar 22, 12:58 AM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGb999edb15f8c: merge-lists: make it possible to specify pattern to match
Summary

The merge-lists tool doesn't know anything about Python other than
its regex that attempts to match import lines. Let's make it possible
to pass in a custom regex so it's easy to use the tool for e.g. C/C++
#include lines or Rust use lines (given the limited).

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

martinvonz created this revision.Tue, Mar 22, 12:58 AM
Alphare accepted this revision as: Alphare.Tue, Mar 22, 5:44 AM
Alphare added a subscriber: Alphare.

The same comments as the last patch apply here.

martinvonz added a comment.Tue, Mar 22, 12:15 PM
In D12392#189755, @Alphare wrote:

The same comments as the last patch apply here.

Done. Thanks again for the tip about clap's "derive" feature!

Alphare added inline comments.Wed, Mar 23, 4:42 AM
contrib/merge-lists/src/main.rs
1

Missing a space here?

martinvonz marked an inline comment as done.Thu, Mar 24, 11:51 AM
martinvonz added a commit: rHGb999edb15f8c: merge-lists: make it possible to specify pattern to match.Wed, Apr 6, 5:45 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHGb999edb15f8c: merge-lists: make it possible to specify pattern to match (authored by martinvonz). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 32787

contrib/merge-lists/src/main.rs

use clap::Parser; use clap::{ArgGroup, Parser};
AlphareUnsubmitted
Done

Missing a space here?

Alphare: Missing a space here?
use itertools::Itertools; use itertools::Itertools;
use regex::bytes::Regex; use regex::bytes::Regex;
use similar::ChangeTag; use similar::ChangeTag;
use std::cmp::{max, min, Ordering}; use std::cmp::{max, min, Ordering};
use std::collections::HashSet; use std::collections::HashSet;
use std::ffi::OsString; use std::ffi::OsString;
use std::ops::Range; use std::ops::Range;
use std::path::PathBuf; use std::path::PathBuf;
(new_base_bytes, new_local_bytes, new_other_bytes) (new_base_bytes, new_local_bytes, new_other_bytes)
} }
/// A tool that performs a 3-way merge, resolving conflicts in sorted lists and /// A tool that performs a 3-way merge, resolving conflicts in sorted lists and
/// leaving other conflicts unchanged. This is useful with Mercurial's support /// leaving other conflicts unchanged. This is useful with Mercurial's support
/// for partial merge tools (configured in `[partial-merge-tools]`). /// for partial merge tools (configured in `[partial-merge-tools]`).
#[derive(Parser, Debug)] #[derive(Parser, Debug)]
#[clap(version, about, long_about = None)] #[clap(version, about, long_about = None)]
#[clap(group(ArgGroup::new("match").required(true).args(&["pattern", "python-imports"])))]
struct Args { struct Args {
/// Path to the file's content in the "local" side /// Path to the file's content in the "local" side
local: OsString, local: OsString,
/// Path to the file's content in the base /// Path to the file's content in the base
base: OsString, base: OsString,
/// Path to the file's content in the "other" side /// Path to the file's content in the "other" side
other: OsString, other: OsString,
/// Regular expression to use
#[clap(long, short)]
pattern: Option<String>,
/// Use built-in regular expression for Python imports
#[clap(long)]
python_imports: bool,
}
fn get_regex(args: &Args) -> Regex {
let pattern = if args.python_imports {
r"import \w+(\.\w+)*( +#.*)?\n|from (\w+(\.\w+)* import \w+( as \w+)?(, \w+( as \w+)?)*( +#.*)?)"
} else if let Some(pattern) = &args.pattern {
pattern
} else {
".*"
};
let pattern = format!(r"{}\r?\n?", pattern);
regex::bytes::Regex::new(&pattern).unwrap()
} }
fn main() { fn main() {
let args: Args = Args::parse(); let args: Args = Args::parse();
let base_path = PathBuf::from(&args.base); let base_path = PathBuf::from(&args.base);
let local_path = PathBuf::from(&args.local); let local_path = PathBuf::from(&args.local);
let other_path = PathBuf::from(&args.other); let other_path = PathBuf::from(&args.other);
let base_bytes = std::fs::read(&base_path).unwrap(); let base_bytes = std::fs::read(&base_path).unwrap();
let local_bytes = std::fs::read(&local_path).unwrap(); let local_bytes = std::fs::read(&local_path).unwrap();
let other_bytes = std::fs::read(&other_path).unwrap(); let other_bytes = std::fs::read(&other_path).unwrap();
let regex = let regex = get_regex(&args);
regex::bytes::Regex::new(r"import \w+(\.\w+)*( +#.*)?\n|from (\w+(\.\w+)* import \w+( as \w+)?(, \w+( as \w+)?)*( +#.*)?)\r?\n?").unwrap();
let (new_base_bytes, new_local_bytes, new_other_bytes) = let (new_base_bytes, new_local_bytes, new_other_bytes) =
resolve(&base_bytes, &local_bytes, &other_bytes, &regex); resolve(&base_bytes, &local_bytes, &other_bytes, &regex);
// Write out the result if anything changed // Write out the result if anything changed
if new_base_bytes != base_bytes { if new_base_bytes != base_bytes {
std::fs::write(&base_path, new_base_bytes).unwrap(); std::fs::write(&base_path, new_base_bytes).unwrap();
} }
if new_local_bytes != local_bytes { if new_local_bytes != local_bytes {

contrib/merge-lists/tests/test-merge-lists.rs

use similar::DiffableStr; use similar::DiffableStr;
use std::ffi::OsStr;
use tempdir::TempDir; use tempdir::TempDir;
fn run_test(input: &str) -> String { fn run_test(arg: &str, input: &str) -> String {
let mut cmd = assert_cmd::Command::cargo_bin("merge-lists").unwrap(); let mut cmd = assert_cmd::Command::cargo_bin("merge-lists").unwrap();
let temp_dir = TempDir::new("test").unwrap(); let temp_dir = TempDir::new("test").unwrap();
let base_path = temp_dir.path().join("base"); let base_path = temp_dir.path().join("base");
let local_path = temp_dir.path().join("local"); let local_path = temp_dir.path().join("local");
let other_path = temp_dir.path().join("other"); let other_path = temp_dir.path().join("other");
let rest = input.strip_prefix("\nbase:\n").unwrap(); let rest = input.strip_prefix("\nbase:\n").unwrap();
let mut split = rest.split("\nlocal:\n"); let mut split = rest.split("\nlocal:\n");
std::fs::write(&base_path, split.next().unwrap()).unwrap(); std::fs::write(&base_path, split.next().unwrap()).unwrap();
let rest = split.next().unwrap(); let rest = split.next().unwrap();
let mut split = rest.split("\nother:\n"); let mut split = rest.split("\nother:\n");
std::fs::write(&local_path, split.next().unwrap()).unwrap(); std::fs::write(&local_path, split.next().unwrap()).unwrap();
std::fs::write(&other_path, split.next().unwrap()).unwrap(); std::fs::write(&other_path, split.next().unwrap()).unwrap();
cmd.args(&[ cmd.args(&[
OsStr::new(arg),
local_path.as_os_str(), local_path.as_os_str(),
base_path.as_os_str(), base_path.as_os_str(),
other_path.as_os_str(), other_path.as_os_str(),
]) ])
.assert() .assert()
.success(); .success();
let new_base_bytes = std::fs::read(&base_path).unwrap(); let new_base_bytes = std::fs::read(&base_path).unwrap();
let new_local_bytes = std::fs::read(&local_path).unwrap(); let new_local_bytes = std::fs::read(&local_path).unwrap();
let new_other_bytes = std::fs::read(&other_path).unwrap(); let new_other_bytes = std::fs::read(&other_path).unwrap();
// No newline before "base:" because of https://github.com/mitsuhiko/insta/issues/117 // No newline before "base:" because of https://github.com/mitsuhiko/insta/issues/117
format!( format!(
"base:\n{}\nlocal:\n{}\nother:\n{}", "base:\n{}\nlocal:\n{}\nother:\n{}",
new_base_bytes.as_str().unwrap(), new_base_bytes.as_str().unwrap(),
new_local_bytes.as_str().unwrap(), new_local_bytes.as_str().unwrap(),
new_other_bytes.as_str().unwrap() new_other_bytes.as_str().unwrap()
) )
} }
#[test] #[test]
fn test_merge_lists_basic() { fn test_merge_lists_basic() {
let output = run_test( let output = run_test(
"--python-imports",
r" r"
base: base:
import lib1 import lib1
import lib2 import lib2
local: local:
import lib2 import lib2
import lib3 import lib3
"###); "###);
} }
#[test] #[test]
fn test_merge_lists_from() { fn test_merge_lists_from() {
// Test some "from x import y" statements and some non-import conflicts // Test some "from x import y" statements and some non-import conflicts
// (unresolvable) // (unresolvable)
let output = run_test( let output = run_test(
"--python-imports",
r" r"
base: base:
from . import x from . import x
1+1 1+1
local: local:
from . import x from . import x
"###); "###);
} }
#[test] #[test]
fn test_merge_lists_not_sorted() { fn test_merge_lists_not_sorted() {
// Test that nothing is done if the elements in the conflicting hunks are // Test that nothing is done if the elements in the conflicting hunks are
// not sorted // not sorted
let output = run_test( let output = run_test(
"--python-imports",
r" r"
base: base:
import x import x
1+1 1+1
local: local:
import a import a
other: other:
import z import z
import y import y
3+3 3+3
"###); "###);
} }
#[test]
fn test_custom_regex() {
// Test merging of all lines (by matching anything)
let output = run_test(
"--pattern=.*",
r"
base:
aardvark
baboon
camel
local:
aardvark
camel
eagle
other:
aardvark
camel
deer
",
);
insta::assert_snapshot!(output, @r###"
base:
aardvark
camel
deer
eagle
local:
aardvark
camel
deer
eagle
other:
aardvark
camel
deer
eagle
"###);
}