code_ownership 2.1.1 → 2.1.3

data/ext/cargo-vendor/similar-2.7.0/src/utils.rs

@@ -0,0 +1,412 @@
+//! Utilities for common diff related operations.
+//!
+//! This module provides specialized utilities and simplified diff operations
+//! for common operations.  It's useful when you want to work with text diffs
+//! and you're interested in getting vectors of these changes directly.
+//!
+//! # Slice Remapping
+//!
+//! When working with [`TextDiff`] it's common that one takes advantage of the
+//! built-in tokenization of the differ.  This for instance lets you do
+//! grapheme level diffs.  This is implemented by the differ generating rather
+//! small slices of strings and running a diff algorithm over them.
+//!
+//! The downside of this is that all the [`DiffOp`] objects produced by the
+//! diffing algorithm encode operations on these rather small slices.  For
+//! a lot of use cases this is not what one wants which can make this very
+//! inconvenient.  This module provides a [`TextDiffRemapper`] which lets you
+//! map from the ranges that the [`TextDiff`] returns to the original input
+//! strings.  For more information see [`TextDiffRemapper`].
+//!
+//! # Simple Diff Functions
+//!
+//! This module provides a range of common test diff functions that will
+//! produce vectors of `(change_tag, value)` tuples.  They will automatically
+//! optimize towards returning the most useful slice that one would expect for
+//! the type of diff performed.
+
+use std::hash::Hash;
+use std::ops::{Index, Range};
+
+use crate::{
+    capture_diff_slices, Algorithm, ChangeTag, DiffOp, DiffableStr, DiffableStrRef, TextDiff,
+};
+
+struct SliceRemapper<'x, T: ?Sized> {
+    source: &'x T,
+    indexes: Vec<Range<usize>>,
+}
+
+impl<'x, T: DiffableStr + ?Sized> SliceRemapper<'x, T> {
+    fn new(source: &'x T, slices: &[&'x T]) -> SliceRemapper<'x, T> {
+        let indexes = slices
+            .iter()
+            .scan(0, |state, item| {
+                let start = *state;
+                let end = start + item.len();
+                *state = end;
+                Some(start..end)
+            })
+            .collect();
+        SliceRemapper { source, indexes }
+    }
+
+    fn slice(&self, range: Range<usize>) -> Option<&'x T> {
+        let start = self.indexes.get(range.start)?.start;
+        let end = self.indexes.get(range.end - 1)?.end;
+        Some(self.source.slice(start..end))
+    }
+}
+
+impl<T: DiffableStr + ?Sized> Index<Range<usize>> for SliceRemapper<'_, T> {
+    type Output = T;
+
+    fn index(&self, range: Range<usize>) -> &Self::Output {
+        self.slice(range).expect("out of bounds")
+    }
+}
+
+/// A remapper that can remap diff ops to the original slices.
+///
+/// The idea here is that when a [`TextDiff`](crate::TextDiff) is created from
+/// two strings and the internal tokenization is used, this remapper can take
+/// a range in the tokenized sequences and remap it to the original string.
+/// This is particularly useful when you want to do things like character or
+/// grapheme level diffs but you want to not have to iterate over small sequences
+/// but large consequitive ones from the source.
+///
+/// ```rust
+/// use similar::{ChangeTag, TextDiff};
+/// use similar::utils::TextDiffRemapper;
+///
+/// let old = "yo! foo bar baz";
+/// let new = "yo! foo bor baz";
+/// let diff = TextDiff::from_words(old, new);
+/// let remapper = TextDiffRemapper::from_text_diff(&diff, old, new);
+/// let changes: Vec<_> = diff.ops()
+///     .iter()
+///     .flat_map(move |x| remapper.iter_slices(x))
+///     .collect();
+///
+/// assert_eq!(changes, vec![
+///     (ChangeTag::Equal, "yo! foo "),
+///     (ChangeTag::Delete, "bar"),
+///     (ChangeTag::Insert, "bor"),
+///     (ChangeTag::Equal, " baz")
+/// ]);
+pub struct TextDiffRemapper<'x, T: ?Sized> {
+    old: SliceRemapper<'x, T>,
+    new: SliceRemapper<'x, T>,
+}
+
+impl<'x, T: DiffableStr + ?Sized> TextDiffRemapper<'x, T> {
+    /// Creates a new remapper from strings and slices.
+    pub fn new(
+        old_slices: &[&'x T],
+        new_slices: &[&'x T],
+        old: &'x T,
+        new: &'x T,
+    ) -> TextDiffRemapper<'x, T> {
+        TextDiffRemapper {
+            old: SliceRemapper::new(old, old_slices),
+            new: SliceRemapper::new(new, new_slices),
+        }
+    }
+
+    /// Creates a new remapper from a text diff and the original strings.
+    pub fn from_text_diff<'old, 'new, 'bufs>(
+        diff: &TextDiff<'old, 'new, 'bufs, T>,
+        old: &'x T,
+        new: &'x T,
+    ) -> TextDiffRemapper<'x, T>
+    where
+        'old: 'x,
+        'new: 'x,
+    {
+        TextDiffRemapper {
+            old: SliceRemapper::new(old, diff.old_slices()),
+            new: SliceRemapper::new(new, diff.new_slices()),
+        }
+    }
+
+    /// Slices into the old string.
+    pub fn slice_old(&self, range: Range<usize>) -> Option<&'x T> {
+        self.old.slice(range)
+    }
+
+    /// Slices into the new string.
+    pub fn slice_new(&self, range: Range<usize>) -> Option<&'x T> {
+        self.new.slice(range)
+    }
+
+    /// Given a diffop yields the changes it encodes against the original strings.
+    ///
+    /// This is the same as the [`DiffOp::iter_slices`] method.
+    ///
+    /// ## Panics
+    ///
+    /// This method can panic if the input strings passed to the constructor
+    /// are incompatible with the input strings passed to the diffing algorithm.
+    pub fn iter_slices(&self, op: &DiffOp) -> impl Iterator<Item = (ChangeTag, &'x T)> {
+        // note: this is equivalent to the code in `DiffOp::iter_slices`.  It is
+        // a copy/paste because the slicing currently cannot be well abstracted
+        // because of lifetime issues caused by the `Index` trait.
+        match *op {
+            DiffOp::Equal { old_index, len, .. } => {
+                Some((ChangeTag::Equal, self.old.slice(old_index..old_index + len)))
+                    .into_iter()
+                    .chain(None)
+            }
+            DiffOp::Insert {
+                new_index, new_len, ..
+            } => Some((
+                ChangeTag::Insert,
+                self.new.slice(new_index..new_index + new_len),
+            ))
+            .into_iter()
+            .chain(None),
+            DiffOp::Delete {
+                old_index, old_len, ..
+            } => Some((
+                ChangeTag::Delete,
+                self.old.slice(old_index..old_index + old_len),
+            ))
+            .into_iter()
+            .chain(None),
+            DiffOp::Replace {
+                old_index,
+                old_len,
+                new_index,
+                new_len,
+            } => Some((
+                ChangeTag::Delete,
+                self.old.slice(old_index..old_index + old_len),
+            ))
+            .into_iter()
+            .chain(Some((
+                ChangeTag::Insert,
+                self.new.slice(new_index..new_index + new_len),
+            ))),
+        }
+        .map(|(tag, opt_val)| (tag, opt_val.expect("slice out of bounds")))
+    }
+}
+
+/// Shortcut for diffing two slices.
+///
+/// This function produces the diff of two slices and returns a vector
+/// with the changes.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_slices;
+///
+/// let old = "foo\nbar\nbaz".lines().collect::<Vec<_>>();
+/// let new = "foo\nbar\nBAZ".lines().collect::<Vec<_>>();
+/// assert_eq!(diff_slices(Algorithm::Myers, &old, &new), vec![
+///     (ChangeTag::Equal, &["foo", "bar"][..]),
+///     (ChangeTag::Delete, &["baz"][..]),
+///     (ChangeTag::Insert, &["BAZ"][..]),
+/// ]);
+/// ```
+pub fn diff_slices<'x, T: PartialEq + Hash + Ord>(
+    alg: Algorithm,
+    old: &'x [T],
+    new: &'x [T],
+) -> Vec<(ChangeTag, &'x [T])> {
+    capture_diff_slices(alg, old, new)
+        .iter()
+        .flat_map(|op| op.iter_slices(old, new))
+        .collect()
+}
+
+/// Shortcut for making a character level diff.
+///
+/// This function produces the diff of two strings and returns a vector
+/// with the changes.  It returns connected slices into the original string
+/// rather than character level slices.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_chars;
+///
+/// assert_eq!(diff_chars(Algorithm::Myers, "foobarbaz", "fooBARbaz"), vec![
+///     (ChangeTag::Equal, "foo"),
+///     (ChangeTag::Delete, "bar"),
+///     (ChangeTag::Insert, "BAR"),
+///     (ChangeTag::Equal, "baz"),
+/// ]);
+/// ```
+pub fn diff_chars<'x, T: DiffableStrRef + ?Sized>(
+    alg: Algorithm,
+    old: &'x T,
+    new: &'x T,
+) -> Vec<(ChangeTag, &'x T::Output)> {
+    let old = old.as_diffable_str();
+    let new = new.as_diffable_str();
+    let diff = TextDiff::configure().algorithm(alg).diff_chars(old, new);
+    let remapper = TextDiffRemapper::from_text_diff(&diff, old, new);
+    diff.ops()
+        .iter()
+        .flat_map(move |x| remapper.iter_slices(x))
+        .collect()
+}
+
+/// Shortcut for making a word level diff.
+///
+/// This function produces the diff of two strings and returns a vector
+/// with the changes.  It returns connected slices into the original string
+/// rather than word level slices.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_words;
+///
+/// assert_eq!(diff_words(Algorithm::Myers, "foo bar baz", "foo bor baz"), vec![
+///     (ChangeTag::Equal, "foo "),
+///     (ChangeTag::Delete, "bar"),
+///     (ChangeTag::Insert, "bor"),
+///     (ChangeTag::Equal, " baz"),
+/// ]);
+/// ```
+pub fn diff_words<'x, T: DiffableStrRef + ?Sized>(
+    alg: Algorithm,
+    old: &'x T,
+    new: &'x T,
+) -> Vec<(ChangeTag, &'x T::Output)> {
+    let old = old.as_diffable_str();
+    let new = new.as_diffable_str();
+    let diff = TextDiff::configure().algorithm(alg).diff_words(old, new);
+    let remapper = TextDiffRemapper::from_text_diff(&diff, old, new);
+    diff.ops()
+        .iter()
+        .flat_map(move |x| remapper.iter_slices(x))
+        .collect()
+}
+
+/// Shortcut for making a unicode word level diff.
+///
+/// This function produces the diff of two strings and returns a vector
+/// with the changes.  It returns connected slices into the original string
+/// rather than word level slices.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_unicode_words;
+///
+/// let old = "The quick (\"brown\") fox can't jump 32.3 feet, right?";
+/// let new = "The quick (\"brown\") fox can't jump 9.84 meters, right?";
+/// assert_eq!(diff_unicode_words(Algorithm::Myers, old, new), vec![
+///     (ChangeTag::Equal, "The quick (\"brown\") fox can\'t jump "),
+///     (ChangeTag::Delete, "32.3"),
+///     (ChangeTag::Insert, "9.84"),
+///     (ChangeTag::Equal, " "),
+///     (ChangeTag::Delete, "feet"),
+///     (ChangeTag::Insert, "meters"),
+///     (ChangeTag::Equal, ", right?")
+/// ]);
+/// ```
+///
+/// This requires the `unicode` feature.
+#[cfg(feature = "unicode")]
+pub fn diff_unicode_words<'x, T: DiffableStrRef + ?Sized>(
+    alg: Algorithm,
+    old: &'x T,
+    new: &'x T,
+) -> Vec<(ChangeTag, &'x T::Output)> {
+    let old = old.as_diffable_str();
+    let new = new.as_diffable_str();
+    let diff = TextDiff::configure()
+        .algorithm(alg)
+        .diff_unicode_words(old, new);
+    let remapper = TextDiffRemapper::from_text_diff(&diff, old, new);
+    diff.ops()
+        .iter()
+        .flat_map(move |x| remapper.iter_slices(x))
+        .collect()
+}
+
+/// Shortcut for making a grapheme level diff.
+///
+/// This function produces the diff of two strings and returns a vector
+/// with the changes.  It returns connected slices into the original string
+/// rather than grapheme level slices.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_graphemes;
+///
+/// let old = "The flag of Austria is 🇦🇹";
+/// let new = "The flag of Albania is 🇦🇱";
+/// assert_eq!(diff_graphemes(Algorithm::Myers, old, new), vec![
+///     (ChangeTag::Equal, "The flag of A"),
+///     (ChangeTag::Delete, "ustr"),
+///     (ChangeTag::Insert, "lban"),
+///     (ChangeTag::Equal, "ia is "),
+///     (ChangeTag::Delete, "🇦🇹"),
+///     (ChangeTag::Insert, "🇦🇱"),
+/// ]);
+/// ```
+///
+/// This requires the `unicode` feature.
+#[cfg(feature = "unicode")]
+pub fn diff_graphemes<'x, T: DiffableStrRef + ?Sized>(
+    alg: Algorithm,
+    old: &'x T,
+    new: &'x T,
+) -> Vec<(ChangeTag, &'x T::Output)> {
+    let old = old.as_diffable_str();
+    let new = new.as_diffable_str();
+    let diff = TextDiff::configure()
+        .algorithm(alg)
+        .diff_graphemes(old, new);
+    let remapper = TextDiffRemapper::from_text_diff(&diff, old, new);
+    diff.ops()
+        .iter()
+        .flat_map(move |x| remapper.iter_slices(x))
+        .collect()
+}
+
+/// Shortcut for making a line diff.
+///
+/// This function produces the diff of two slices and returns a vector
+/// with the changes.  Unlike [`diff_chars`] or [`diff_slices`] it returns a
+/// change tag for each line.
+///
+/// ```rust
+/// use similar::{Algorithm, ChangeTag};
+/// use similar::utils::diff_lines;
+///
+/// assert_eq!(diff_lines(Algorithm::Myers, "foo\nbar\nbaz\nblah", "foo\nbar\nbaz\nblurgh"), vec![
+///     (ChangeTag::Equal, "foo\n"),
+///     (ChangeTag::Equal, "bar\n"),
+///     (ChangeTag::Equal, "baz\n"),
+///     (ChangeTag::Delete, "blah"),
+///     (ChangeTag::Insert, "blurgh"),
+/// ]);
+/// ```
+pub fn diff_lines<'x, T: DiffableStrRef + ?Sized>(
+    alg: Algorithm,
+    old: &'x T,
+    new: &'x T,
+) -> Vec<(ChangeTag, &'x T::Output)> {
+    TextDiff::configure()
+        .algorithm(alg)
+        .diff_lines(old, new)
+        .iter_all_changes()
+        .map(|change| (change.tag(), change.value()))
+        .collect()
+}
+
+#[test]
+fn test_remapper() {
+    let a = "foo bar baz";
+    let words = a.tokenize_words();
+    dbg!(&words);
+    let remap = SliceRemapper::new(a, &words);
+    assert_eq!(remap.slice(0..3), Some("foo bar"));
+    assert_eq!(remap.slice(1..3), Some(" bar"));
+    assert_eq!(remap.slice(0..1), Some("foo"));
+    assert_eq!(remap.slice(0..5), Some("foo bar baz"));
+    assert_eq!(remap.slice(0..6), None);
+}

data/ext/cargo-vendor/unicode-ident-1.0.19/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{".cargo_vcs_info.json":"5416fcff6fa0c6611cec99144bd5690f506c7875b8263ddeae6f123e22c3b50c",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"3f09084970623b248ee41aaa7928e8e1e4298a712a6621334580951a3227495b","Cargo.lock":"2b727ff15f388012e929c089fdb62ead00fdb88a720a34c0e5c88b98748dc186","Cargo.toml":"92d59ecf8e5c840a4cad498e6fa36ccb34ae1aa3c2ceec2abd258b129fae67d1","Cargo.toml.orig":"afbf880657a9fd530a2c7e47f3e91e388a5a4b313580e82ad0618a3f0d043823","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"14a5b144df5ffd729c605286a8b2abe4733f147197b5142e60d6bc77ea44854c","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"9fdfc52c5695b4bdf6a777afe6705f18f50a9d05939f17fbede0e84aeef11c64","src/tables.rs":"9afe268f3a6087a96d4217aaf2fe9ebd5418f133bd733193009df7dccebf154b","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/.gitignore":"2cd419079c0a08bb15766520880998651dd1c72c55347a31f43357595b16ac10","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"3a3467bad2bbb0cef8f0fe953967e16bc0b0a865ec52fd7eb34d620e9b3a11d4","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"}
+{"files":{".cargo_vcs_info.json":"5416fcff6fa0c6611cec99144bd5690f506c7875b8263ddeae6f123e22c3b50c",".github/FUNDING.yml":"b017158736b3c9751a2d21edfce7fe61c8954e2fced8da8dd3013c2f3e295bd9",".github/workflows/ci.yml":"3f09084970623b248ee41aaa7928e8e1e4298a712a6621334580951a3227495b","Cargo.lock":"2b727ff15f388012e929c089fdb62ead00fdb88a720a34c0e5c88b98748dc186","Cargo.toml":"92d59ecf8e5c840a4cad498e6fa36ccb34ae1aa3c2ceec2abd258b129fae67d1","Cargo.toml.orig":"afbf880657a9fd530a2c7e47f3e91e388a5a4b313580e82ad0618a3f0d043823","LICENSE-APACHE":"62c7a1e35f56406896d7aa7ca52d0cc0d272ac022b5d2796e7d6905db8a3636a","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","LICENSE-UNICODE":"f7db81051789b729fea528a63ec4c938fdcb93d9d61d97dc8cc2e9df6d47f2a1","README.md":"14a5b144df5ffd729c605286a8b2abe4733f147197b5142e60d6bc77ea44854c","benches/xid.rs":"7eb058c1140a253f7177af8868a95aabb1b92c52dc7eee5abbfeadb507d7845d","src/lib.rs":"9fdfc52c5695b4bdf6a777afe6705f18f50a9d05939f17fbede0e84aeef11c64","src/tables.rs":"9afe268f3a6087a96d4217aaf2fe9ebd5418f133bd733193009df7dccebf154b","tests/compare.rs":"f2311271aa1db7380e5bf153ef83ee99777e14579e4f28c2b1a3e21877ffe715","tests/fst/mod.rs":"69a3aaf59acd8bca962ecc6234be56be8c0934ab79b253162f10eb881523901f","tests/fst/xid_continue.fst":"b58be4f0c498253e7a5ac664046096f15f249da66131347d4b822097623549a2","tests/fst/xid_start.fst":"aec7eecdacfce308d2e6210f47d28ed3aad5c8b048efbfbc11fc22e60fbf435b","tests/roaring/mod.rs":"f5c6d55463a7f53e92a493cf046d717149250fbafc0e0fe94bdb531377bf8b11","tests/static_size.rs":"3a3467bad2bbb0cef8f0fe953967e16bc0b0a865ec52fd7eb34d620e9b3a11d4","tests/tables/mod.rs":"e6949172d10fc4b2431ce7546269bfd4f9146454c8c3e31faf5e5d80c16a8ab6","tests/tables/tables.rs":"302d87306100b6280f8db93e167dc70c47f724045cf1312b7354683656c3f36b","tests/trie/mod.rs":"d4acbb716bcbaf80660039797f45e138ed8bbd66749fa3b19b1a971574679cc9","tests/trie/trie.rs":"f7b9edc1e8a98e3be42b653bba27bb4eb5fc48a559d6d8d1c6a4db4b5425b0d5"},"package":"f63a545481291138910575129486daeaf8ac54aee4387fe7906919f7830c7d9d"}

data/ext/code_ownership/Cargo.toml

@@ -17,7 +17,7 @@ rb-sys = { version = "0.9.111", features = [
 magnus = { version = "0.8" }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_magnus = "0.10"
-codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.3.0" }
+codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.3.3" }
 
 [dev-dependencies]
 rb-sys = { version = "0.9.117", features = [

data/ext/code_ownership/src/lib.rs

@@ -109,14 +109,14 @@ fn build_run_config() -> RunConfig {
         Ok(path) => path,
         _ => PathBuf::from("."),
     };
-    let codeowners_file_path = project_root.join(".github/CODEOWNERS");
     let config_path = project_root.join("config/code_ownership.yml");
 
     RunConfig {
         project_root,
-        codeowners_file_path,
+        codeowners_file_path: None,
         config_path,
         no_cache: false,
+        executable_name: Some("bin/codeownership validate".to_string()),
     }
 }
 

data/lib/code_ownership/private/file_path_finder.rb

@@ -6,13 +6,29 @@ module CodeOwnership
     module FilePathFinder
       extend T::Sig
 
+      sig { returns(String) }
+      def self.pwd_prefix
+        @pwd_prefix ||= T.let("#{Dir.pwd}/", T.nilable(String))
+      end
+
+      sig { returns(Pathname) }
+      def self.pwd
+        @pwd ||= T.let(Pathname.pwd, T.nilable(Pathname))
+      end
+
       # Returns a string version of the relative path to a Rails constant,
       # or nil if it can't find anything
       sig { params(klass: T.nilable(T.any(T::Class[T.anything], T::Module[T.anything]))).returns(T.nilable(String)) }
       def self.path_from_klass(klass)
         if klass
           path = Object.const_source_location(klass.to_s)&.first
-          (path && Pathname.new(path).relative_path_from(Pathname.pwd).to_s) || nil
+          return nil unless path
+
+          if path.start_with?(pwd_prefix)
+            path.delete_prefix(pwd_prefix)
+          else
+            Pathname.new(path).relative_path_from(pwd).to_s
+          end
         end
       rescue NameError
         nil
@@ -30,7 +46,7 @@ module CodeOwnership
         #   ./app/controllers/some_controller.rb:43:in `block (3 levels) in create'
         #
         backtrace_line = if RUBY_VERSION >= '3.4.0'
-                           %r{\A(#{Pathname.pwd}/|\./)?
+                           %r{\A(#{pwd}/|\./)?
                                (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
                                :
                                (?<line>\d+)      # Matches '43'
@@ -38,7 +54,7 @@ module CodeOwnership
                                '(?<function>.*)' # Matches "`block (3 levels) in create'"
                              \z}x
                          else
-                           %r{\A(#{Pathname.pwd}/|\./)?
+                           %r{\A(#{pwd}/|\./)?
                                (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
                                :
                                (?<line>\d+)      # Matches '43'

data/lib/code_ownership/private/team_finder.rb

@@ -13,9 +13,8 @@ module CodeOwnership
         return FilePathTeamCache.get(file_path) if FilePathTeamCache.cached?(file_path)
 
         result = T.let(RustCodeOwners.for_file(file_path), T.nilable(T::Hash[Symbol, String]))
-        return if result.nil?
 
-        if result[:team_name].nil?
+        if result.nil? || result[:team_name].nil?
           FilePathTeamCache.set(file_path, nil)
         else
           FilePathTeamCache.set(file_path, T.let(find_team!(T.must(result[:team_name]), allow_raise: allow_raise), T.nilable(CodeTeams::Team)))

data/lib/code_ownership/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module CodeOwnership
-  VERSION = '2.1.1'
+  VERSION = '2.1.3'
 end

data/lib/code_ownership.rb

@@ -315,5 +315,7 @@ module CodeOwnership
   sig { void }
   def self.bust_caches!
     Private::FilePathTeamCache.bust_cache!
+    Private::FilePathFinder.instance_variable_set(:@pwd, nil)
+    Private::FilePathFinder.instance_variable_set(:@pwd_prefix, nil)
   end
 end