( )⚙ D12392 merge-lists: make it possible to specify pattern to match

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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 32698

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
"###);
}