replacing implementation with fast_code_owners

Author: perryqh

Cargo.lock

@@ -105,17 +105,6 @@ This defaults `**/`, which makes it look for `package.json` files across your ap
 js_package_paths: []
 ```
 
-### Custom Ownership
-To enable custom ownership, you can inject your own custom classes into `code_ownership`.
-To do this, first create a class that adheres to the `CodeOwnership::Mapper` and/or `CodeOwnership::Validator` interface.
-Then, in `config/code_ownership.yml`, you can require that file:
-```yml
-require:
-  - ./lib/my_extension.rb
-```
-
-Now, `bin/codeownership validate` will automatically include your new mapper and/or validator. See [`spec/lib/code_ownership/private/extension_loader_spec.rb](spec/lib/code_ownership/private/extension_loader_spec.rb) for an example of what this looks like.
-
 ## Usage: Reading CodeOwnership
 ### `for_file`
 `CodeOwnership.for_file`, given a relative path to a file returns a `CodeTeams::Team` if there is a team that owns the file, `nil` otherwise.

README.md

@@ -18,10 +18,10 @@ 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.4" }
-codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", branch = "ph.fast-file-check" }
+codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", branch = "ph.blazing-fast-for-file" }
 
 [dev-dependencies]
-rb-sys = { version = "0.9.111", features = [
+rb-sys = { version = "0.9.117", features = [
   "link-ruby",
   "bindgen-rbimpls",
   "bindgen-deprecated-types",

ext/code_ownership/Cargo.toml

@@ -11,6 +11,12 @@ pub struct Team {
     pub team_config_yml: String,
 }
 
+fn for_team(team_name: String) -> Result<Value, Error> {
+    let run_config = build_run_config();
+    let team = runner::for_team(&run_config, &team_name);
+    validate_result(&team)
+}
+
 fn for_file(file_path: String) -> Result<Option<Value>, Error> {
     let run_config = build_run_config();
 
@@ -35,12 +41,11 @@ fn validate() -> Result<Value, Error> {
     let run_config = build_run_config();
     let run_result = runner::validate(&run_config, vec![]);
     validate_result(&run_result)
-    
 }
 
-fn generate_and_validate() -> Result<Value, Error> {
+fn generate_and_validate(skip_stage: bool) -> Result<Value, Error> {
     let run_config = build_run_config();
-    let run_result = runner::generate_and_validate(&run_config, vec![]);
+    let run_result = runner::generate_and_validate(&run_config, vec![], skip_stage);
     validate_result(&run_result)
 }
 
@@ -60,7 +65,6 @@ fn validate_result(run_result: &runner::RunResult) -> Result<Value, Error> {
         Ok(serialized)
     }
 }
-
 fn build_run_config() -> RunConfig {
     let project_root = match env::current_dir() {
         Ok(path) => path,
@@ -81,8 +85,44 @@ fn build_run_config() -> RunConfig {
 fn init(ruby: &Ruby) -> Result<(), Error> {
     let module = ruby.define_module("RustCodeOwners")?;
     module.define_singleton_method("for_file", function!(for_file, 1))?;
-    module.define_singleton_method("generate_and_validate", function!(generate_and_validate, 0))?;
+    module.define_singleton_method("generate_and_validate", function!(generate_and_validate, 1))?;
     module.define_singleton_method("validate", function!(validate, 0))?;
+    module.define_singleton_method("for_team", function!(for_team, 1))?;
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use std::env::set_current_dir;
+
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn test_for_file_with_invalid_path() {
+        // panics because not called from a ruby thread
+        let _result = for_file("invalid/path".to_string());
+    }
+
+    #[test]
+    fn test_for_file() {
+        let argv: [*mut c_char; 0] = [];
+        let argv = argv.as_ptr();
+        let mut argc = 1;
+
+        let manifest_dir = env!("CARGO_MANIFEST_DIR");
+        let fixture_path = PathBuf::from(manifest_dir).join("tests/fixtures/valid_project");
+        let _ = set_current_dir(&fixture_path).unwrap();
+
+        unsafe {
+            rb_sys::ruby_sysinit(&mut argc, argv as _);
+            rb_sys::ruby_init();
+
+            init();
+            let result = generate_and_validate();
+            assert!(result.is_ok());
+            rb_sys::ruby_cleanup(0);
+        }
+    }
+}

ext/code_ownership/src/lib.rs

@@ -8,11 +8,10 @@
 require 'json'
 require 'packs-specification'
 require 'code_ownership/version'
-require 'code_ownership/mapper'
-require 'code_ownership/validator'
-require 'code_ownership/private'
+require 'code_ownership/file_path_finder'
+require 'code_ownership/file_path_team_cache'
+require 'code_ownership/team_finder'
 require 'code_ownership/cli'
-require 'code_ownership/configuration'
 
 begin
   RUBY_VERSION =~ /(\d+\.\d+)/
@@ -22,7 +21,7 @@
 end
 
 if defined?(Packwerk)
-  require 'code_ownership/private/permit_pack_owner_top_level_key'
+  require 'code_ownership/permit_pack_owner_top_level_key'
 end
 
 module CodeOwnership
@@ -36,50 +35,13 @@ module CodeOwnership
 
   sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
   def for_file(file)
-    @for_file ||= T.let(@for_file, T.nilable(T::Hash[String, T.nilable(CodeTeams::Team)]))
-    @for_file ||= {}
-
-    return nil if file.start_with?('./')
-    return @for_file[file] if @for_file.key?(file)
-
-    Private.load_configuration!
-
-    owner = T.let(nil, T.nilable(CodeTeams::Team))
-
-    Mapper.all.each do |mapper|
-      owner = mapper.map_file_to_owner(file)
-      break if owner # TODO: what if there are multiple owners? Should we respond with an error instead of the first match?
-    end
-
-    @for_file[file] = owner
+    TeamFinder.for_file(file)
   end
 
   sig { params(team: T.any(CodeTeams::Team, String)).returns(String) }
   def for_team(team)
     team = T.must(CodeTeams.find(team)) if team.is_a?(String)
-    ownership_information = T.let([], T::Array[String])
-
-    ownership_information << "# Code Ownership Report for `#{team.name}` Team"
-
-    Private.glob_cache.raw_cache_contents.each do |mapper_description, glob_to_owning_team_map|
-      ownership_information << "## #{mapper_description}"
-      ownership_for_mapper = []
-      glob_to_owning_team_map.each do |glob, owning_team|
-        next if owning_team != team
-
-        ownership_for_mapper << "- #{glob}"
-      end
-
-      if ownership_for_mapper.empty?
-        ownership_information << 'This team owns nothing in this category.'
-      else
-        ownership_information += ownership_for_mapper.sort
-      end
-
-      ownership_information << ''
-    end
-
-    ownership_information.join("\n")
+    ::RustCodeOwners.for_team(team.name)
   end
 
   class InvalidCodeOwnershipConfigurationError < StandardError
@@ -102,92 +64,35 @@ def validate!(
     stage_changes: true,
     files: nil
   )
-    Private.validate!(autocorrect: autocorrect, stage_changes: stage_changes)
+    if autocorrect
+      ::RustCodeOwners.generate_and_validate(!stage_changes)
+    else
+      ::RustCodeOwners.validate
+    end
   end
 
   # Given a backtrace from either `Exception#backtrace` or `caller`, find the
   # 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: [])
-    first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)&.first
+    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: [])
-    backtrace_with_ownership(backtrace).each do |(team, file)|
-      if team && !excluded_teams.include?(team)
-        return [team, file]
-      end
-    end
-
-    nil
-  end
-
-  sig { params(backtrace: T.nilable(T::Array[String])).returns(T::Enumerable[[T.nilable(::CodeTeams::Team), String]]) }
-  def backtrace_with_ownership(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
-
-      file = T.must(match[:file])
-
-      [
-        CodeOwnership.for_file(file),
-        file
-      ]
-    end
+    TeamFinder.first_owned_file_for_backtrace(backtrace, excluded_teams: excluded_teams)
   end
-  private_class_method(:backtrace_with_ownership)
 
   sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
   def for_class(klass)
-    @memoized_values ||= T.let(@memoized_values, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)]))
-    @memoized_values ||= {}
-    # We use key because the memoized value could be `nil`
-    if @memoized_values.key?(klass.to_s)
-      @memoized_values[klass.to_s]
-    else
-      path = Private.path_from_klass(klass)
-      return nil if path.nil?
-
-      value_to_memoize = for_file(path)
-      @memoized_values[klass.to_s] = value_to_memoize
-      value_to_memoize
-    end
+    TeamFinder.for_class(klass)
   end
 
   sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
   def for_package(package)
-    Private::OwnershipMappers::PackageOwnership.new.owner_for_package(package)
+    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.
@@ -196,14 +101,6 @@ def for_package(package)
   # has different ownership and tracked files.
   sig { void }
   def self.bust_caches!
-    @for_file = nil
-    @memoized_values = nil
-    Private.bust_caches!
-    Mapper.all.each(&:bust_caches!)
-  end
-
-  sig { returns(Configuration) }
-  def self.configuration
-    Private.configuration
+    FilePathTeamCache.bust_cache!
   end
 end