providng a for-file verbose option

Author: perryqh

Cargo.lock

@@ -17,7 +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.7" }
+codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.2.14" }
 
 [dev-dependencies]
 rb-sys = { version = "0.9.117", features = [

ext/code_ownership/Cargo.toml

@@ -9,6 +9,7 @@ use serde_magnus::serialize;
 pub struct Team {
     pub team_name: String,
     pub team_config_yml: String,
+    pub reasons: Vec<String>,
 }
 
 fn for_team(team_name: String) -> Result<Value, Error> {
@@ -20,16 +21,24 @@ fn for_team(team_name: String) -> Result<Value, Error> {
 fn for_file(file_path: String) -> Result<Option<Value>, Error> {
     let run_config = build_run_config();
 
-    match runner::team_for_file(&run_config, &file_path) {
-        Ok(Some(team_rs)) => {
+    match runner::file_owner_for_file(&run_config, &file_path) {
+        Ok(owner) => {
+            if let Some(owner) = owner {
             let team = Team {
-                team_name: team_rs.name,
-                team_config_yml: team_rs.path.to_string_lossy().to_string(),
+                team_name: owner.team.name,
+                team_config_yml: owner.team_config_file_path.to_string(),
+                reasons: owner
+                .sources
+                .iter()
+                .map(|source| source.to_string())
+                .collect(),
             };
             let serialized: Value = serialize(&team)?;
             Ok(Some(serialized))
+            } else {
+                Ok(None)
+            }
         }
-        Ok(None) => Ok(None),
         Err(e) => Err(Error::new(
             magnus::exception::runtime_error(),
             e.to_string(),

ext/code_ownership/src/lib.rs

@@ -44,6 +44,11 @@ def for_file(file)
     Private::TeamFinder.for_file(file)
   end
 
+  sig { params(file: String).returns(T.nilable(T::Hash[Symbol, String])) }
+  def for_file_verbose(file)
+    ::RustCodeOwners.for_file(file)
+  end
+
   sig { params(team: T.any(CodeTeams::Team, String)).returns(T::Array[String]) }
   def for_team(team)
     team = T.must(CodeTeams.find(team)) if team.is_a?(String)

lib/code_ownership.rb

@@ -95,6 +95,10 @@ def self.for_file(argv)
           options[:json] = true
         end
 
+        opts.on('--verbose', 'Output verbose information') do
+          options[:verbose] = true
+        end
+
         opts.on('--help', 'Shows this prompt') do
           puts opts
           exit
@@ -107,18 +111,26 @@ def self.for_file(argv)
         raise "Please pass in one file. Use `#{EXECUTABLE} for_file --help` for more info"
       end
 
-      team = CodeOwnership.for_file(files.first)
+      if options[:verbose]
+        for_file_verbose(file: files.first, json: options[:json])
+      else
+        for_file_terse(file: files.first, json: options[:json])
+      end
+    end
+
+    def self.for_file_terse(file:, json:)
+      team = CodeOwnership.for_file(file)
 
       team_name = team&.name || 'Unowned'
       team_yml = team&.config_yml || 'Unowned'
 
-      if options[:json]
-        json = {
+      if json
+        json_output = {
           team_name: team_name,
           team_yml: team_yml
         }
 
-        puts json.to_json
+        puts json_output.to_json
       else
         puts <<~MSG
           Team: #{team_name}
@@ -127,6 +139,28 @@ def self.for_file(argv)
       end
     end
 
+    def self.for_file_verbose(file:, json:)
+      verbose = CodeOwnership.for_file_verbose(file) || {team_name: 'Unowned', team_config_yml: 'Unowned', reasons: []}
+
+      if json
+        json = {
+          team_name: verbose[:team_name],
+          team_yml: verbose[:team_config_yml],
+          reasons: verbose[:reasons]
+        }
+
+        puts json.to_json
+      else
+        messages = ["Team: #{verbose[:team_name]}", "Team YML: #{verbose[:team_config_yml]}"]
+        if verbose[:reasons].any?
+          messages << "Reasons:\n- #{verbose[:reasons].join("\n-")}"
+        end
+        messages.last << "\n"
+
+        puts messages.join("\n")
+      end
+    end
+
     def self.for_team(argv)
       parser = OptionParser.new do |opts|
         opts.banner = "Usage: #{EXECUTABLE} for_team 'Team Name'"

lib/code_ownership/cli.rb

@@ -176,6 +176,20 @@ def initialize
         end
       end
 
+      context 'when run with --verbose' do
+        let(:argv) { ['for_file', 'app/services/my_file.rb', '--verbose'] }
+
+        it 'outputs the team info in human readable format' do
+          expect(CodeOwnership::Cli).to receive(:puts).with(<<~MSG)
+            Team: My Team
+            Team YML: config/teams/my_team.yml
+            Reasons:
+            - Owner specified in Team YML as an owned_glob `app/**/*.rb`
+          MSG
+          subject
+        end
+      end
+
       context 'when run with no files' do
         let(:argv) { ['for_file'] }
 
@@ -205,6 +219,19 @@ def initialize
           expect(CodeOwnership::Cli).to receive(:puts).with(json.to_json)
           subject
         end
+
+        context 'when run with multiple files' do
+          let(:argv) { ['for_file', '--json', '--verbose', 'app/services/my_file.rb'] }
+          it 'outputs JSONified information to the console' do
+            json = {
+              team_name: 'My Team',
+              team_yml: 'config/teams/my_team.yml',
+              reasons: ['Owner specified in Team YML as an owned_glob `app/**/*.rb`']
+            }
+            expect(CodeOwnership::Cli).to receive(:puts).with(json.to_json)
+            subject
+          end  
+        end
       end
 
       context 'when run with no files' do
@@ -235,6 +262,19 @@ def initialize
         MSG
         subject
       end
+
+      context 'when run with --verbose' do
+        let(:argv) { ['for_file', 'app/services/unowned.rb', '--verbose'] }
+
+        it 'prints Unowned' do
+          allow(CodeOwnership).to receive(:for_file_verbose).and_return(nil)
+          expect(CodeOwnership::Cli).to receive(:puts).with(<<~MSG)
+            Team: Unowned
+            Team YML: Unowned
+          MSG
+          subject
+        end
+      end
     end
 
     context 'with --help' do