add additional test cases

crates/rome_cli/tests/commands/format.rs

@@ -1111,13 +1111,16 @@ fn does_not_format_ignored_directories() {
         CONFIG_FORMATTER_IGNORED_DIRECTORIES.as_bytes(),
     );
 
-    const FILES: [(&str, bool); 6] = [
+    const FILES: [(&str, bool); 9] = [
         ("test.js", true),
         ("test1.js", false),
         ("test2.js", false),
         ("test3/test.js", false),
         ("test4/test.js", true),
         ("test5/test.js", false),
+        ("test6/test.js", false),
+        ("test/test.test7.js", false),
+        ("test.test7.js", false),
     ];
 
     for (file_path, _) in FILES {

crates/rome_cli/tests/configs.rs

@@ -212,7 +212,9 @@ pub const CONFIG_FORMATTER_IGNORED_DIRECTORIES: &str = r#"{
       "./test2.js",
       "./test3/**/*",
       "/test4/**/*",
-      "test5/**/*"
+      "test5/**/*",
+      "**/test6/*.js",
+      "*.test7.js"
     ]
   }
 }

crates/rome_cli/tests/snapshots/main_commands_format/does_not_format_ignored_directories.snap

@@ -12,7 +12,9 @@ expression: content
       "./test2.js",
       "./test3/**/*",
       "/test4/**/*",
-      "test5/**/*"
+      "test5/**/*",
+      "**/test6/*.js",
+      "*.test7.js"
     ]
   }
 }
@@ -26,6 +28,18 @@ statement();
 
 ```
 
+## `test.test7.js`
+
+```js
+  statement(  )  
+```
+
+## `test/test.test7.js`
+
+```js
+  statement(  )  
+```
+
 ## `test1.js`
 
 ```js
@@ -57,6 +71,12 @@ statement();
   statement(  )  
 ```
 
+## `test6/test.js`
+
+```js
+  statement(  )  
+```
+
 # Emitted Messages
 
 ```block

crates/rome_lsp/tests/server.rs

@@ -48,6 +48,10 @@ use tower_lsp::lsp_types::WorkDoneProgressParams;
 use tower_lsp::LspService;
 use tower_lsp::{jsonrpc::Request, lsp_types::InitializeParams};
 
+/// Statically build an [lsp::Url] instance that points to the file at `$path`
+/// within the workspace. The filesystem path contained in the return URI is
+/// guaranteed to be a valid path for the underlying operating system, but
+/// doesn't have to refer to an existing file on the host machine.
 macro_rules! url {
     ($path:literal) => {
         if cfg!(windows) {

crates/rome_service/src/matcher/pattern.rs

@@ -122,17 +122,20 @@ impl Pattern {
         let mut is_recursive = false;
         let mut i = 0;
 
-        // A pattern is relative if it starts with "." followed by a separator
+        // A pattern is relative if it starts with "." followed by a separator,
+        // eg. "./test" or ".\test"
         let is_relative = matches!(chars.get(..2), Some(['.', sep]) if path::is_separator(*sep));
         if is_relative {
-            // If a pattern starts with a relative prefix, strip it from the pattern and replace it with "**"
+            // If a pattern starts with a relative prefix, strip it from the
+            // pattern and replace it with a "**" sequence
             i += 2;
             tokens.push(AnyRecursiveSequence);
         } else {
-            // A pattern is absolute if it starts with a path separator
+            // A pattern is absolute if it starts with a path separator, eg. "/home" or "\\?\C:\Users"
             let mut is_absolute = chars.first().map_or(false, |c| path::is_separator(*c));
 
-            // On windows a pattern may also be absolute if it starts with a drive letter, a colon and a separator
+            // On windows a pattern may also be absolute if it starts with a
+            // drive letter, a colon and a separator, eg. "c:/Users" or "G:\Users"
             if cfg!(windows) && !is_absolute {
                 is_absolute = matches!(chars.get(..3), Some(['a'..='z' | 'A'..='Z', ':', sep]) if path::is_separator(*sep));
             }
@@ -856,4 +859,40 @@ mod test {
         let pattern = Path::new("one").join(Path::new("**/*.rs"));
         assert!(Pattern::new(pattern.to_str().unwrap()).is_ok());
     }
+
+    #[test]
+    fn test_pattern_relative() {
+        assert!(Pattern::new("./b").unwrap().matches_path(Path::new("a/b")));
+        assert!(Pattern::new("b").unwrap().matches_path(Path::new("a/b")));
+
+        if cfg!(windows) {
+            assert!(Pattern::new(".\\b")
+                .unwrap()
+                .matches_path(Path::new("a\\b")));
+            assert!(Pattern::new("b").unwrap().matches_path(Path::new("a\\b")));
+        }
+    }
+
+    #[test]
+    fn test_pattern_absolute() {
+        assert!(Pattern::new("/a/b")
+            .unwrap()
+            .matches_path(Path::new("/a/b")));
+
+        if cfg!(windows) {
+            assert!(Pattern::new("c:/a/b")
+                .unwrap()
+                .matches_path(Path::new("c:/a/b")));
+            assert!(Pattern::new("C:\\a\\b")
+                .unwrap()
+                .matches_path(Path::new("C:\\a\\b")));
+
+            assert!(Pattern::new("\\\\?\\c:\\a\\b")
+                .unwrap()
+                .matches_path(Path::new("\\\\?\\c:\\a\\b")));
+            assert!(Pattern::new("\\\\?\\C:/a/b")
+                .unwrap()
+                .matches_path(Path::new("\\\\?\\C:/a/b")));
+        }
+    }
 }