allow raise predicate

Author: perryqh

Cargo.lock

@@ -17,8 +17,7 @@ rb-sys = { version = "0.9.111", features = [
 magnus = { version = "0.7.1" }
 serde = { version = "1.0.219", features = ["derive"] }
 serde_magnus = "0.9.0"
-# codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.2.17" }
-codeowners = { path = "../../../codeowners-rs" }
+codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.2.17" }
 
 [dev-dependencies]
 rb-sys = { version = "0.9.117", features = [

ext/code_ownership/Cargo.toml

@@ -40,26 +40,18 @@ def version
      "codeowners-rs version: #{::RustCodeOwners.version}"]
   end
 
-  # Returns the team that owns the given file based on the CODEOWNERS file.
-  # This is much faster and can be safely used when the CODEOWNERS files is up to date.
-  # Examples of reliable usage:
-  # - running in CI pipeline
-  # - running on the server
-  # Examples of unreliable usage:
-  # - running in IDE when files are changing and the CODEOWNERS file is not getting updated
-  sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
-  def for_file_from_codeowners(file)
-    teams_for_files_from_codeowners([file]).values.first
-  end
-
-  sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
-  def for_file(file)
-    Private::TeamFinder.for_file(file)
+  sig { params(file: String, from_codeowners: T::Boolean, allow_raise: T::Boolean).returns(T.nilable(CodeTeams::Team)) }
+  def for_file(file, from_codeowners: true, allow_raise: false)
+    if from_codeowners
+      teams_for_files_from_codeowners([file], allow_raise: allow_raise).values.first
+    else
+      Private::TeamFinder.for_file(file, allow_raise: allow_raise)
+    end
   end
 
-  sig { params(files: T::Array[String]).returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
-  def teams_for_files_from_codeowners(files)
-    Private::TeamFinder.teams_for_files(files)
+  sig { params(files: T::Array[String], allow_raise: T::Boolean).returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
+  def teams_for_files_from_codeowners(files, allow_raise: false)
+    Private::TeamFinder.teams_for_files(files, allow_raise: allow_raise)
   end
 
   sig { params(file: String).returns(T.nilable(T::Hash[Symbol, String])) }

lib/code_ownership.rb

@@ -53,7 +53,7 @@ def build_verbose
 
       sig { returns(T::Hash[Symbol, T.untyped]) }
       def build_terse
-        team = CodeOwnership.for_file(@file_path)
+        team = CodeOwnership.for_file(@file_path, from_codeowners: false, allow_raise: true)
 
         if team.nil?
           UNOWNED_OUTPUT

lib/code_ownership/code_ownership.bundle

@@ -12,8 +12,8 @@ module TeamFinder
 
       requires_ancestor { Kernel }
 
-      sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
-      def for_file(file_path)
+      sig { params(file_path: String, allow_raise: T::Boolean).returns(T.nilable(CodeTeams::Team)) }
+      def for_file(file_path, allow_raise: false)
         return nil if file_path.start_with?('./')
 
         return FilePathTeamCache.get(file_path) if FilePathTeamCache.cached?(file_path)
@@ -24,17 +24,17 @@ def for_file(file_path)
         if result[:team_name].nil?
           FilePathTeamCache.set(file_path, nil)
         else
-          FilePathTeamCache.set(file_path, T.let(find_team!(T.must(result[:team_name])), T.nilable(CodeTeams::Team)))
+          FilePathTeamCache.set(file_path, T.let(find_team!(T.must(result[:team_name]), allow_raise: allow_raise), T.nilable(CodeTeams::Team)))
         end
 
         FilePathTeamCache.get(file_path)
       end
 
-      sig { params(files: T::Array[String]).returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
-      def teams_for_files(files)
+      sig { params(files: T::Array[String], allow_raise: T::Boolean).returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
+      def teams_for_files(files, allow_raise: false)
         ::RustCodeOwners.teams_for_files(files).each_with_object({}) do |path_team, hash|
           file_path, team = path_team
-          found_team = team ? CodeTeams.find(team[:team_name]) : nil
+          found_team = team ? find_team!(team[:team_name], allow_raise: allow_raise) : nil
           FilePathTeamCache.set(file_path, found_team)
           hash[file_path] = found_team
         end
@@ -53,7 +53,7 @@ def for_package(package)
         owner_name = package.raw_hash['owner'] || package.metadata['owner']
         return nil if owner_name.nil?
 
-        find_team!(owner_name)
+        find_team!(owner_name, allow_raise: true)
       end
 
       sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable(::CodeTeams::Team)) }
@@ -73,10 +73,14 @@ def first_owned_file_for_backtrace(backtrace, excluded_teams: [])
         nil
       end
 
-      sig { params(team_name: String).returns(CodeTeams::Team) }
-      def find_team!(team_name)
-        CodeTeams.find(team_name) ||
+      sig { params(team_name: String, allow_raise: T::Boolean).returns(T.nilable(CodeTeams::Team)) }
+      def find_team!(team_name, allow_raise: false)
+        team = CodeTeams.find(team_name)
+        if team.nil? && allow_raise
           raise(StandardError, "Could not find team with name: `#{team_name}`. Make sure the team is one of `#{CodeTeams.all.map(&:name).sort}`")
+        end
+
+        team
       end
 
       private_class_method(:find_team!)

lib/code_ownership/private/for_file_output_builder.rb

@@ -64,11 +64,22 @@
           expect(subject).to eq({ 'packs/my_pack/owned_file.rb' => nil })
         end
       end
+
+      context 'when ownership is found but team is not found and allow_raise is true' do
+        let(:files) { ['packs/my_pack/owned_file.rb'] }
+        before do
+          allow(RustCodeOwners).to receive(:teams_for_files).and_return({ files.first => { team_name: 'Made Up Team' } })
+        end
+
+        it 'raises an error' do
+          expect { CodeOwnership.teams_for_files_from_codeowners(files, allow_raise: true) }.to raise_error(StandardError, /Could not find team with name:/)
+        end
+      end
     end
   end
 
   describe '.for_file_from_codeowners' do
-    subject { CodeOwnership.for_file_from_codeowners(file_path) }
+    subject { CodeOwnership.for_file(file_path, from_codeowners: true) }
 
     context 'when config is not found' do
       let(:file_path) { 'app/javascript/[test]/test.js' }
@@ -124,6 +135,17 @@
           expect(subject).to be_nil
         end
       end
+
+      context 'when ownership is found but team is not found and allow_raise is true' do
+        let(:file_path) { 'packs/my_pack/owned_file.rb' }
+        before do
+          allow(RustCodeOwners).to receive(:teams_for_files).and_return({ file_path => { team_name: 'Made Up Team' } })
+        end
+
+        it 'raises an error' do
+          expect { CodeOwnership.for_file(file_path, from_codeowners: true, allow_raise: true) }.to raise_error(StandardError, /Could not find team with name:/)
+        end
+      end
     end
   end
 
@@ -139,6 +161,8 @@
     context 'with non-empty application' do
       before do
         create_non_empty_application
+        # codeowners-rs is matching files against the codeowners file for default path
+        RustCodeOwners.generate_and_validate(false)
       end
 
       context 'when no ownership is found' do
@@ -165,11 +189,25 @@
       context 'when ownership is found but team is not found' do
         let(:file_path) { 'packs/my_pack/owned_file.rb' }
         before do
-          allow(RustCodeOwners).to receive(:for_file).and_return({ team_name: 'Made Up Team' })
+          allow(RustCodeOwners).to receive(:teams_for_files).and_return({ file_path => { team_name: 'Made Up Team' } })
         end
 
-        it 'raises an error' do
-          expect { subject }.to raise_error(StandardError, /Could not find team with name: `Made Up Team`. Make sure the team is one of/)
+        it 'returns nil by default' do
+          expect(subject).to be_nil
+        end
+      end
+
+      context 'when ownership is found but team is not found and allow_raise is true' do
+        let(:file_path) { 'packs/my_pack/owned_file.rb' }
+
+        it 'raises an error when using from_codeowners path' do
+          allow(RustCodeOwners).to receive(:teams_for_files).and_return({ file_path => { team_name: 'Made Up Team' } })
+          expect { CodeOwnership.for_file(file_path, allow_raise: true) }.to raise_error(StandardError, /Could not find team with name:/)
+        end
+
+        it 'raises an error when using single-file path' do
+          allow(RustCodeOwners).to receive(:for_file).and_return({ team_name: 'Made Up Team' })
+          expect { CodeOwnership.for_file(file_path, from_codeowners: false, allow_raise: true) }.to raise_error(StandardError, /Could not find team with name:/)
         end
       end
     end