private for consistency

Author: perryqh

lib/code_ownership.rb

@@ -8,9 +8,9 @@
 require 'json'
 require 'packs-specification'
 require 'code_ownership/version'
-require 'code_ownership/file_path_finder'
-require 'code_ownership/file_path_team_cache'
-require 'code_ownership/team_finder'
+require 'code_ownership/private/file_path_finder'
+require 'code_ownership/private/file_path_team_cache'
+require 'code_ownership/private/team_finder'
 require 'code_ownership/cli'
 require 'code_ownership/mapper'
 
@@ -22,7 +22,7 @@
 end
 
 if defined?(Packwerk)
-  require 'code_ownership/permit_pack_owner_top_level_key'
+  require 'code_ownership/private/permit_pack_owner_top_level_key'
 end
 
 module CodeOwnership
@@ -36,7 +36,7 @@ module CodeOwnership
 
   sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
   def for_file(file)
-    TeamFinder.for_file(file)
+    Private::TeamFinder.for_file(file)
   end
 
   sig { params(team: T.any(CodeTeams::Team, String)).returns(T::Array[String]) }
@@ -71,24 +71,24 @@ def validate!(
   # first line that corresponds to a file with assigned ownership
   sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable(::CodeTeams::Team)) }
   def for_backtrace(backtrace, excluded_teams: [])
-    TeamFinder.for_backtrace(backtrace, excluded_teams: excluded_teams)
+    Private::TeamFinder.for_backtrace(backtrace, excluded_teams: excluded_teams)
   end
 
   # Given a backtrace from either `Exception#backtrace` or `caller`, find the
   # first owned file in it, useful for figuring out which file is being blamed.
   sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable([::CodeTeams::Team, String])) }
   def first_owned_file_for_backtrace(backtrace, excluded_teams: [])
-    TeamFinder.first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)
+    Private::TeamFinder.first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)
   end
 
   sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
   def for_class(klass)
-    TeamFinder.for_class(klass)
+    Private::TeamFinder.for_class(klass)
   end
 
   sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
   def for_package(package)
-    TeamFinder.for_package(package)
+    Private::TeamFinder.for_package(package)
   end
 
   # Generally, you should not ever need to do this, because once your ruby process loads, cached content should not change.
@@ -97,6 +97,6 @@ def for_package(package)
   # has different ownership and tracked files.
   sig { void }
   def self.bust_caches!
-    FilePathTeamCache.bust_cache!
+    Private::FilePathTeamCache.bust_cache!
   end
 end

lib/code_ownership/file_path_finder.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module CodeOwnership
+  module Private
+    module FilePathFinder
+      module_function
+
+      extend T::Sig
+      extend T::Helpers
+
+      # 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], Module))).returns(T.nilable(String)) }
+      def 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
+        end
+      rescue NameError
+        nil
+      end
+
+      sig { params(backtrace: T.nilable(T::Array[String])).returns(T::Enumerable[String]) }
+      def from_backtrace(backtrace)
+        return [] unless backtrace
+
+        # The pattern for a backtrace hasn't changed in forever and is considered
+        # stable: https://github.com/ruby/ruby/blob/trunk/vm_backtrace.c#L303-L317
+        #
+        # This pattern matches a line like the following:
+        #
+        #   ./app/controllers/some_controller.rb:43:in `block (3 levels) in create'
+        #
+        backtrace_line = if RUBY_VERSION >= '3.4.0'
+                           %r{\A(#{Pathname.pwd}/|\./)?
+                               (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
+                               :
+                               (?<line>\d+)      # Matches '43'
+                               :in\s
+                               '(?<function>.*)' # Matches "`block (3 levels) in create'"
+                             \z}x
+                         else
+                           %r{\A(#{Pathname.pwd}/|\./)?
+                               (?<file>.+)       # Matches 'app/controllers/some_controller.rb'
+                               :
+                               (?<line>\d+)      # Matches '43'
+                               :in\s
+                               `(?<function>.*)' # Matches "`block (3 levels) in create'"
+                             \z}x
+                         end
+
+        backtrace.lazy.filter_map do |line|
+          match = line.match(backtrace_line)
+          next unless match
+
+          T.must(match[:file])
+        end
+      end
+    end
+  end
+end

lib/code_ownership/file_path_team_cache.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module CodeOwnership
+  module Private
+    module FilePathTeamCache
+      module_function
+
+      extend T::Sig
+      extend T::Helpers
+
+      sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
+      def get(file_path)
+        cache[file_path]
+      end
+
+      sig { params(file_path: String, team: T.nilable(CodeTeams::Team)).void }
+      def set(file_path, team)
+        cache[file_path] = team
+      end
+
+      sig { params(file_path: String).returns(T::Boolean) }
+      def cached?(file_path)
+        cache.key?(file_path)
+      end
+
+      sig { void }
+      def bust_cache!
+        @cache = nil
+      end
+
+      sig { returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
+      def cache
+        @cache ||= T.let(@cache,
+          T.nilable(T::Hash[String, T.nilable(CodeTeams::Team)]))
+        @cache ||= {}
+      end
+    end
+  end
+end

lib/code_ownership/private/file_path_finder.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# typed: strict
+
+module CodeOwnership
+  module Private
+    module TeamFinder
+      module_function
+
+      extend T::Sig
+      extend T::Helpers
+
+      requires_ancestor { Kernel }
+
+      sig { params(file_path: String).returns(T.nilable(CodeTeams::Team)) }
+      def for_file(file_path)
+        return nil if file_path.start_with?('./')
+
+        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?
+          FilePathTeamCache.set(file_path, nil)
+        else
+          FilePathTeamCache.set(file_path, T.let(find_team!(T.must(result[:team_name])), T.nilable(CodeTeams::Team)))
+        end
+
+        FilePathTeamCache.get(file_path)
+      end
+
+      sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
+      def for_class(klass)
+        file_path = FilePathFinder.path_from_klass(klass)
+        return nil if file_path.nil?
+
+        for_file(file_path)
+      end
+
+      sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
+      def for_package(package)
+        owner_name = package.raw_hash['owner'] || package.metadata['owner']
+        return nil if owner_name.nil?
+
+        find_team!(owner_name)
+      end
+
+      sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable(::CodeTeams::Team)) }
+      def for_backtrace(backtrace, excluded_teams: [])
+        first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)&.first
+      end
+
+      sig { params(backtrace: T.nilable(T::Array[String]), excluded_teams: T::Array[::CodeTeams::Team]).returns(T.nilable([::CodeTeams::Team, String])) }
+      def first_owned_file_for_backtrace(backtrace, excluded_teams: [])
+        FilePathFinder.from_backtrace(backtrace).each do |file|
+          team = for_file(file)
+          if team && !excluded_teams.include?(team)
+            return [team, file]
+          end
+        end
+
+        nil
+      end
+
+      sig { params(team_name: String).returns(CodeTeams::Team) }
+      def find_team!(team_name)
+        CodeTeams.find(team_name) ||
+          raise(StandardError, "Could not find team with name: `#{team_name}`. Make sure the team is one of `#{CodeTeams.all.map(&:name).sort}`")
+      end
+
+      private_class_method(:find_team!)
+    end
+  end
+end