feat: use semver to match required version

Cargo.toml

@@ -58,6 +58,7 @@ unicode-width = "0.1"
 unicode-properties = { version = "0.1", default-features = false, features = ["general-category"] }
 
 rustfmt-config_proc_macro = { version = "0.3", path = "config_proc_macro" }
+semver = "1.0.21"
 
 # Rustc dependencies are loaded from the sysroot, Cargo doesn't know about them.
 

Configurations.md

@@ -2353,7 +2353,7 @@ Require a specific version of rustfmt. If you want to make sure that the
 specific version of rustfmt is used in your CI, use this option.
 
 - **Default value**: `CARGO_PKG_VERSION`
-- **Possible values**: any published version (e.g. `"0.3.8"`)
+- **Possible values**: `semver` compliant values, such as defined on [semver.org](https://semver.org/). Multiple values can be used, they should be separeted by a comma, e.g.: `1.0.0, 1.1.0`. By default, values without comparison operators are treated as `^` (caret) version requirements. If you want to specify an exact version, use the operator `=`, e.g.: `=1.0.0`.
 - **Stable**: No (tracking issue: [#3386](https://github.com/rust-lang/rustfmt/issues/3386))
 
 ## `short_array_element_width_threshold`

src/config/mod.rs

@@ -216,14 +216,23 @@ impl PartialConfig {
 impl Config {
     pub(crate) fn version_meets_requirement(&self) -> bool {
         if self.was_set().required_version() {
-            let version = env!("CARGO_PKG_VERSION");
-            let required_version = self.required_version();
-            if version != required_version {
-                println!(
-                    "Error: rustfmt version ({version}) doesn't match the required version \
-({required_version})"
-                );
-                return false;
+            let version = semver::Version::parse(env!("CARGO_PKG_VERSION")).unwrap();
+            let required_version = semver::VersionReq::parse(self.required_version().as_str());
+
+            match required_version {
+                Ok(required_version) => {
+                    if !required_version.matches(&version) {
+                        eprintln!(
+                            "Error: rustfmt version ({}) doesn't match the required version ({})",
+                            version, required_version
+                        );
+                        return false;
+                    }
+                }
+                Err(e) => {
+                    eprintln!("Error: failed to parse required version: {}", e);
+                    return false;
+                }
             }
         }
 
@@ -1065,4 +1074,217 @@ make_backup = false
             ])
         );
     }
+
+    #[cfg(test)]
+    mod required_version {
+        use super::*;
+
+        #[allow(dead_code)] // Only used in tests
+        fn get_current_version() -> semver::Version {
+            semver::Version::parse(env!("CARGO_PKG_VERSION")).unwrap()
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_default() {
+            let config = Config::default();
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_current_required_version() {
+            let toml = format!("required_version=\"{}\"", env!("CARGO_PKG_VERSION"));
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_above() {
+            let toml = "required_version=\"1000.0.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_below() {
+            let versions = vec!["0.0.0", "0.0.1", "0.1.0"];
+
+            for version in versions {
+                let toml = format!("required_version=\"{}\"", version.to_string());
+                let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+                assert!(!config.version_meets_requirement());
+            }
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_tilde() {
+            let toml = format!("required_version=\"~{}\"", env!("CARGO_PKG_VERSION"));
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_caret() {
+            let current_version = get_current_version();
+
+            for minor in current_version.minor..0 {
+                let toml = format!(
+                    "required_version=\"^{}.{}.0\"",
+                    current_version.major.to_string(),
+                    minor.to_string()
+                );
+                let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+                assert!(!config.version_meets_requirement());
+            }
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_greater_than() {
+            let toml = "required_version=\">1.0.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_less_than() {
+            let toml = "required_version=\"<1.0.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_range() {
+            let current_version = get_current_version();
+
+            let toml = format!(
+                "required_version=\">={}.0.0, <{}.0.0\"",
+                current_version.major,
+                current_version.major + 1
+            );
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_exact_boundary() {
+            let toml = format!("required_version=\"{}\"", get_current_version().to_string());
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_pre_release() {
+            let toml = format!(
+                "required_version=\"{}-alpha\"",
+                get_current_version().to_string()
+            );
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_with_build_metadata() {
+            let toml = format!(
+                "required_version=\"{}+build.1\"",
+                get_current_version().to_string()
+            );
+
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_invalid_specification() {
+            let toml = "required_version=\"not.a.version\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement())
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_complex_range() {
+            let current_version = get_current_version();
+
+            let toml = format!(
+                "required_version=\">={}.0.0, <{}.0.0, ~{}.{}.0\"",
+                current_version.major,
+                current_version.major + 1,
+                current_version.major,
+                current_version.minor
+            );
+            let config = Config::from_toml(&toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_wildcard_major() {
+            let toml = "required_version=\"1.x\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_wildcard_any() {
+            let toml = "required_version=\"*\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_major_version_zero() {
+            let toml = "required_version=\"0.1.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_future_major_version() {
+            let toml = "required_version=\"3.0.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement());
+        }
+
+        #[nightly_only_test]
+        #[test]
+        fn test_required_version_fail_different_operator() {
+            // != is not supported
+            let toml = "required_version=\"!=1.0.0\"";
+            let config = Config::from_toml(toml, Path::new("")).unwrap();
+
+            assert!(!config.version_meets_requirement());
+        }
+    }
 }