2025-08-13 07:47:38 +02:00 · 2025-08-13 07:53:42 +02:00 · 2025-08-13 14:44:51 +02:00 · 2025-08-13 14:50:41 +02:00 · 2025-08-13 07:56:22 +02:00 · 2025-08-13 07:58:04 +02:00
10 changed files with 135 additions and 5 deletions
--- a/doc/src/usage.md
+++ b/doc/src/usage.md
@ -60,6 +60,11 @@ $ mergiraf languages --gitattributes

 If you want to enable Mergiraf only in a certain repository, add the lines above in the `.gitattributes` file at the root of that repository instead, or in `.git/info/attributes` if you don't want it to be tracked in the repository.

+If `mergiraf` does not recognize your file's language by extension, you may set the `mergiraf.language` attribute on the file to specify it manually:
+```
+*.myjs  mergiraf.language=javascript
+```
+
 #### Trying it out

 An [example repository](https://codeberg.org/mergiraf/example-repo) is available for you to try out Mergiraf on simple examples:
--- a/mgf_dev/src/main.rs
+++ b/mgf_dev/src/main.rs
@ -66,7 +66,11 @@ fn real_main(args: &CliArgs) -> Result<i32, String> {
    let ref_arena = Arena::new();

    let lang_profile = |language_determining_path| {
-        LangProfile::find_by_filename_or_name(language_determining_path, args.language.as_deref())
+        LangProfile::find_by_filename_or_name(
+            language_determining_path,
+            args.language.as_deref(),
+            None,
+        )
    };

    let contents = |path: &Path| -> Result<Cow<str>, String> {
--- a/src/git.rs
+++ b/src/git.rs
@ -94,3 +94,35 @@ pub(crate) fn read_content_from_commits(
        read_content_from_commit(repo_dir, oids.2, file_name)?,
    ))
 }
+
+pub(crate) fn read_attribute_for_file(
+    repo_dir: &Path,
+    file_name: &Path,
+    attr: &str,
+) -> Option<String> {
+    Command::new("git")
+        .args([
+            "check-attr",
+            "-z",
+            attr,
+            "--",
+            &format!("{}", file_name.display()),
+        ])
+        .current_dir(repo_dir)
+        .output()
+        .ok()
+        .filter(|output| output.status.success())
+        .and_then(|output| {
+            output
+                .stdout
+                .split(|b| *b == b'\0')
+                .nth(2)
+                .map(|value| value.to_vec())
+        })
+        .and_then(|c| String::from_utf8(c).ok())
+}
+
+pub(crate) fn read_lang_attribute(repo_dir: &Path, file_name: &Path) -> Option<String> {
+    read_attribute_for_file(repo_dir, file_name, "mergiraf.language")
+        .filter(|value| value != "unspecified" && value != "set" && value != "unset")
+}
--- a/src/lang_profile.rs
+++ b/src/lang_profile.rs
@ -3,7 +3,7 @@ use std::{collections::HashSet, ffi::OsStr, fmt::Display, hash::Hash, path::Path
 use itertools::Itertools;
 use tree_sitter::Language;

-use crate::{signature::SignatureDefinition, supported_langs::SUPPORTED_LANGUAGES};
+use crate::{git, signature::SignatureDefinition, supported_langs::SUPPORTED_LANGUAGES};

 /// Language-dependent settings to influence how merging is done.
 /// All those settings are declarative (except for the tree-sitter parser, which is
@ -94,10 +94,19 @@ impl LangProfile {
        inner(filename.as_ref())
    }

+    /// Detects the language of a file based on VCS attributes
+    pub fn detect_language_from_vcs_attr<P>(repo_dir: &Path, filename: P) -> Option<String>
+    where
+        P: AsRef<Path>,
+    {
+        git::read_lang_attribute(repo_dir, filename.as_ref())
+    }
+
    /// Loads a language either by name or by detecting it from a filename
    pub fn find_by_filename_or_name<P>(
        filename: P,
        language_name: Option<&str>,
+        repo_dir: Option<&Path>,
    ) -> Result<&'static Self, String>
    where
        P: AsRef<Path>,
@ -106,6 +115,12 @@ impl LangProfile {
        if let Some(lang_name) = language_name {
            Self::find_by_name(lang_name)
                .ok_or_else(|| format!("Specified language '{lang_name}' could not be found"))
+        } else if let Some(lang_name) =
+            repo_dir.and_then(|repo_dir| Self::detect_language_from_vcs_attr(repo_dir, filename))
+        {
+            Self::find_by_name(&lang_name).ok_or_else(|| {
+                format!("Attribute-specified language '{lang_name}' could not be found")
+            })
        } else {
            Self::detect_from_filename(filename).ok_or_else(|| {
                format!(
@ -374,6 +389,8 @@ impl ChildrenGroup {

 #[cfg(test)]
 mod tests {
+    use std::{env, fs::File, io::Write, process::Command};
+
    use super::*;

    use crate::test_utils::ctx;
@ -408,7 +425,7 @@ mod tests {
    #[test]
    fn find_by_filename_or_name() {
        fn find(filename: &str, name: Option<&str>) -> Result<&'static LangProfile, String> {
-            LangProfile::find_by_filename_or_name(filename, name)
+            LangProfile::find_by_filename_or_name(filename, name, None)
        }
        assert_eq!(find("file.json", None).unwrap().name, "JSON");
        assert_eq!(find("file.java", Some("JSON")).unwrap().name, "JSON");
@ -425,4 +442,67 @@ mod tests {
            "Looking up language by unknown extension should fail"
        );
    }
+
+    #[test]
+    fn find_by_filename_or_name_vcs() {
+        let mut working_dir = env::current_exe().unwrap();
+        working_dir.pop();
+        let tempdir = tempfile::tempdir_in(working_dir).unwrap();
+
+        Command::new("git")
+            .arg("init")
+            .current_dir(&tempdir)
+            .output()
+            .expect("failed to init git repository");
+        {
+            let attrpath = tempdir.path().join(".gitattributes");
+            let mut attrfile = File::create(attrpath).unwrap();
+            write!(
+                &mut attrfile,
+                concat!(
+                    "*.bogus    mergiraf.language=bogus\n",
+                    "*.js       mergiraf.language=javascript\n",
+                    "*.myjs     mergiraf.language=javascript\n",
+                ),
+            )
+            .unwrap();
+        }
+        Command::new("git")
+            .args([
+                "-c",
+                "user.email=mergiraf@example.com",
+                "-c",
+                "user.name=Mergiraf Testing",
+                "commit",
+                "-a",
+                "-m",
+                "add gitattributes",
+            ])
+            .current_dir(&tempdir)
+            .output()
+            .expect("failed to commit attribute file");
+
+        fn find_impl(
+            filename: &str,
+            name: Option<&str>,
+            repo_dir: &Path,
+        ) -> Result<&'static LangProfile, String> {
+            LangProfile::find_by_filename_or_name(filename, name, Some(repo_dir))
+        }
+        let find = |filename, name| find_impl(filename, name, tempdir.path());
+        assert_eq!(
+            find("file.bogus", None).unwrap_err(),
+            "Attribute-specified language 'bogus' could not be found",
+        );
+        assert_eq!(
+            find("file.noattr", None).unwrap_err(),
+            "Could not find a supported language for file.noattr",
+        );
+        assert_eq!(find("file.js", None).unwrap().name, "Javascript");
+        assert_eq!(find("file.myjs", None).unwrap().name, "Javascript");
+        assert_eq!(find("file.bogus", Some("python")).unwrap().name, "Python");
+        assert_eq!(find("file.noattr", Some("python")).unwrap().name, "Python");
+        assert_eq!(find("file.js", Some("python")).unwrap().name, "Python");
+        assert_eq!(find("file.myjs", Some("python")).unwrap().name, "Python");
+    }
 }
--- a/src/main.rs
+++ b/src/main.rs
@ -243,6 +243,7 @@ fn real_main(args: CliArgs) -> Result<i32, String> {

            let fname_base = path_name.unwrap_or(fname_base);

+            let working_dir = env::current_dir().expect("Invalid current directory");
            let merge_result = line_merge_and_structured_resolution(
                contents_base,
                contents_left,
@ -254,6 +255,7 @@ fn real_main(args: CliArgs) -> Result<i32, String> {
                debug_dir,
                Duration::from_millis(timeout.unwrap_or(if fast { 5000 } else { 10000 })),
                language.as_deref(),
+                Some(&working_dir),
            );
            if let Some(fname_out) = output {
                write_string_to_file(&fname_out, &merge_result.contents)?;
--- a/src/merge.rs
+++ b/src/merge.rs
@ -36,8 +36,10 @@ pub fn line_merge_and_structured_resolution(
    debug_dir: Option<&'static Path>,
    timeout: Duration,
    language: Option<&str>,
+    repo_dir: Option<&Path>,
 ) -> MergeResult {
-    let Ok(lang_profile) = LangProfile::find_by_filename_or_name(fname_base, language) else {
+    let Ok(lang_profile) = LangProfile::find_by_filename_or_name(fname_base, language, repo_dir)
+    else {
        return line_based_merge(&contents_base, contents_left, &contents_right, &settings);
    };

--- a/src/solve.rs
+++ b/src/solve.rs
@ -24,7 +24,8 @@ pub fn resolve_merge_cascading<'a>(
 ) -> Result<MergeResult, String> {
    let mut solves = Vec::with_capacity(4);

-    let lang_profile = LangProfile::find_by_filename_or_name(fname_base, language)?;
+    let lang_profile =
+        LangProfile::find_by_filename_or_name(fname_base, language, Some(working_dir))?;

    let parsed = match ParsedMerge::parse(merge_contents, &settings) {
        Err(err) => {
--- a/tests/failing.rs
+++ b/tests/failing.rs
@ -78,6 +78,7 @@ fn integration_failing(
        None,
        Duration::from_millis(0),
        language_override_for_test(&test_dir),
+        None,
    );

    let actual = &merge_result.contents;
@ -144,6 +145,7 @@ please examine the new output and update ExpectedCurrently{suffix} if it looks o
        None,
        Duration::from_millis(0),
        None,
+        None,
    );

    let actual_compact = &merge_result.contents;
--- a/tests/timeout_support.rs
+++ b/tests/timeout_support.rs
@ -39,6 +39,7 @@ fn timeout_support() {
        None,
        Duration::from_millis(1), // very small timeout: structured merging should never be that fast
        None,
+        None,
    );

    let expected = contents_expected.trim();
--- a/tests/working.rs
+++ b/tests/working.rs
@ -39,6 +39,7 @@ fn compare_against_merge(
        None,
        Duration::from_millis(0),
        language_override_for_test(test_dir),
+        None,
    );

    let expected = contents_expected;