code_ownership 2.1.0 → 2.1.1

data/ext/code_ownership/Cargo.toml

@@ -14,9 +14,9 @@ rb-sys = { version = "0.9.111", features = [
     "bindgen-deprecated-types",
     "stable-api-compiled-fallback",
 ] }
-magnus = { version = "0.7.1" }
+magnus = { version = "0.8" }
 serde = { version = "1.0.219", features = ["derive"] }
-serde_magnus = "0.9.0"
+serde_magnus = "0.10"
 codeowners = { git = "https://github.com/rubyatscale/codeowners-rs.git", tag = "v0.3.0" }
 
 [dev-dependencies]

data/ext/code_ownership/extconf.rb

@@ -3,7 +3,8 @@
 require 'mkmf'
 require 'rb_sys/mkmf'
 
-create_rust_makefile('code_ownership/code_ownership') do |ext|
+ruby_minor = RUBY_VERSION[/\d+\.\d+/]
+create_rust_makefile("code_ownership/#{ruby_minor}/code_ownership") do |ext|
   ext.extra_cargo_args += ['--crate-type', 'cdylib']
   ext.extra_cargo_args += ['--package', 'code_ownership']
 end

data/ext/code_ownership/src/lib.rs

@@ -12,13 +12,13 @@ pub struct Team {
     pub reasons: Vec<String>,
 }
 
-fn for_team(team_name: String) -> Result<Value, Error> {
+fn for_team(ruby: &Ruby, team_name: String) -> Result<Value, Error> {
     let run_config = build_run_config();
     let team = runner::for_team(&run_config, &team_name);
-    validate_result(&team)
+    validate_result(ruby, &team)
 }
 
-fn teams_for_files(file_paths: Vec<String>) -> Result<Value, Error> {
+fn teams_for_files(ruby: &Ruby, file_paths: Vec<String>) -> Result<Value, Error> {
     let run_config = build_run_config();
     let path_teams = runner::teams_for_files_from_codeowners(&run_config, &file_paths);
     match path_teams {
@@ -35,14 +35,14 @@ fn teams_for_files(file_paths: Vec<String>) -> Result<Value, Error> {
                     teams_map.insert(path, None);
                 }
             }
-            let serialized: Value = serialize(&teams_map)?;
+            let serialized: Value = serialize(ruby, &teams_map)?;
             Ok(serialized)
         }
-        Err(e) => Err(Error::new(magnus::exception::runtime_error(), e.to_string())),
+        Err(e) => Err(Error::new(ruby.exception_runtime_error(), e.to_string())),
     }
 }
 
-fn for_file(file_path: String) -> Result<Option<Value>, Error> {
+fn for_file(ruby: &Ruby, file_path: String) -> Result<Option<Value>, Error> {
     let run_config = build_run_config();
 
     match runner::file_owner_for_file(&run_config, &file_path) {
@@ -57,14 +57,14 @@ fn for_file(file_path: String) -> Result<Option<Value>, Error> {
                 .map(|source| source.to_string())
                 .collect(),
             };
-            let serialized: Value = serialize(&team)?;
+            let serialized: Value = serialize(ruby, &team)?;
             Ok(Some(serialized))
             } else {
                 Ok(None)
             }
         }
         Err(e) => Err(Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             e.to_string(),
         )),
     }
@@ -74,33 +74,33 @@ fn version() -> String {
    runner::version()
 }
 
-fn validate(files: Option<Vec<String>>) -> Result<Value, Error> {
+fn validate(ruby: &Ruby, files: Option<Vec<String>>) -> Result<Value, Error> {
     let run_config = build_run_config();
     let files_vec = files.unwrap_or_default();
     let run_result = runner::validate(&run_config, files_vec);
-    validate_result(&run_result)
+    validate_result(ruby, &run_result)
 }
 
-fn generate_and_validate(files: Option<Vec<String>>, skip_stage: bool) -> Result<Value, Error> {
+fn generate_and_validate(ruby: &Ruby, files: Option<Vec<String>>, skip_stage: bool) -> Result<Value, Error> {
     let run_config = build_run_config();
     let files_vec = files.unwrap_or_default();
     let run_result = runner::generate_and_validate(&run_config, files_vec, skip_stage);
-    validate_result(&run_result)
+    validate_result(ruby, &run_result)
 }
 
-fn validate_result(run_result: &runner::RunResult) -> Result<Value, Error> {
+fn validate_result(ruby: &Ruby, run_result: &runner::RunResult) -> Result<Value, Error> {
     if !run_result.validation_errors.is_empty() {
         Err(Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             run_result.validation_errors.join("\n"),
         ))
     } else if !run_result.io_errors.is_empty() {
         Err(Error::new(
-            magnus::exception::runtime_error(),
+            ruby.exception_runtime_error(),
             run_result.io_errors.join("\n"),
         ))
     } else {
-        let serialized: Value = serialize(&run_result.info_messages)?;
+        let serialized: Value = serialize(ruby, &run_result.info_messages)?;
         Ok(serialized)
     }
 }

data/lib/code_ownership/cli.rb

@@ -1,4 +1,5 @@
 # typed: true
+# frozen_string_literal: true
 
 require 'optparse'
 require 'pathname'

data/lib/code_ownership/private/file_path_finder.rb

@@ -1,19 +1,15 @@
 # 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)
+      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
@@ -23,7 +19,7 @@ module CodeOwnership
       end
 
       sig { params(backtrace: T.nilable(T::Array[String])).returns(T::Enumerable[String]) }
-      def from_backtrace(backtrace)
+      def self.from_backtrace(backtrace)
         return [] unless backtrace
 
         # The pattern for a backtrace hasn't changed in forever and is considered

data/lib/code_ownership/private/file_path_team_cache.rb

@@ -1,37 +1,33 @@
 # 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)
+      def self.get(file_path)
         cache[file_path]
       end
 
       sig { params(file_path: String, team: T.nilable(CodeTeams::Team)).void }
-      def set(file_path, team)
+      def self.set(file_path, team)
         cache[file_path] = team
       end
 
       sig { params(file_path: String).returns(T::Boolean) }
-      def cached?(file_path)
+      def self.cached?(file_path)
         cache.key?(file_path)
       end
 
       sig { void }
-      def bust_cache!
+      def self.bust_cache!
         @cache = nil
       end
 
       sig { returns(T::Hash[String, T.nilable(CodeTeams::Team)]) }
-      def cache
+      def self.cache
         @cache ||= T.let(@cache,
           T.nilable(T::Hash[String, T.nilable(CodeTeams::Team)]))
         @cache ||= {}

data/lib/code_ownership/private/for_file_output_builder.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 # typed: strict
 
 module CodeOwnership

data/lib/code_ownership/private/team_finder.rb

@@ -1,19 +1,13 @@
 # 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, allow_raise: T::Boolean).returns(T.nilable(CodeTeams::Team)) }
-      def for_file(file_path, allow_raise: false)
+      def self.for_file(file_path, allow_raise: false)
         return nil if file_path.start_with?('./')
 
         return FilePathTeamCache.get(file_path) if FilePathTeamCache.cached?(file_path)
@@ -31,7 +25,7 @@ module CodeOwnership
       end
 
       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)
+      def self.teams_for_files(files, allow_raise: false)
         result = {}
 
         # Collect cached results and identify non-cached files
@@ -57,8 +51,8 @@ module CodeOwnership
         result
       end
 
-      sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(::CodeTeams::Team)) }
-      def for_class(klass)
+      sig { params(klass: T.nilable(T.any(T::Class[T.anything], T::Module[T.anything]))).returns(T.nilable(::CodeTeams::Team)) }
+      def self.for_class(klass)
         file_path = FilePathFinder.path_from_klass(klass)
         return nil if file_path.nil?
 
@@ -66,7 +60,7 @@ module CodeOwnership
       end
 
       sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
-      def for_package(package)
+      def self.for_package(package)
         owner_name = package.raw_hash['owner'] || package.metadata['owner']
         return nil if owner_name.nil?
 
@@ -74,12 +68,12 @@ module CodeOwnership
       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: [])
+      def self.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: [])
+      def self.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)
@@ -91,7 +85,7 @@ module CodeOwnership
       end
 
       sig { params(team_name: String, allow_raise: T::Boolean).returns(T.nilable(CodeTeams::Team)) }
-      def find_team!(team_name, allow_raise: false)
+      def self.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}`")

data/lib/code_ownership/version.rb

@@ -1,6 +1,6 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module CodeOwnership
-  VERSION = '2.1.0'
+  VERSION = '2.1.1'
 end

data/lib/code_ownership.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 # typed: strict
 
 require 'code_teams'
@@ -25,17 +24,13 @@ if defined?(Packwerk)
 end
 
 module CodeOwnership
-  module_function
-
   extend T::Sig
-  extend T::Helpers
 
-  requires_ancestor { Kernel }
   GlobsToOwningTeamMap = T.type_alias { T::Hash[String, CodeTeams::Team] }
 
   # Returns the version of the code_ownership gem and the codeowners-rs gem.
   sig { returns(T::Array[String]) }
-  def version
+  def self.version
     ["code_ownership version: #{VERSION}",
      "codeowners-rs version: #{::RustCodeOwners.version}"]
   end
@@ -65,7 +60,7 @@ module CodeOwnership
   #   # => raises exception if no owner found
   #
   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)
+  def self.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
@@ -116,7 +111,7 @@ module CodeOwnership
   # @see #validate! for ensuring CODEOWNERS file is up-to-date
   #
   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)
+  def self.teams_for_files_from_codeowners(files, allow_raise: false)
     Private::TeamFinder.teams_for_files(files, allow_raise: allow_raise)
   end
 
@@ -160,12 +155,12 @@ module CodeOwnership
   # @see CLI#for_file for the command-line interface that uses this method
   #
   sig { params(file: String).returns(T.nilable(T::Hash[Symbol, String])) }
-  def for_file_verbose(file)
+  def self.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)
+  def self.for_team(team)
     team = T.must(CodeTeams.find(team)) if team.is_a?(String)
     ::RustCodeOwners.for_team(team.name)
   end
@@ -226,7 +221,7 @@ module CodeOwnership
       files: T.nilable(T::Array[String])
     ).void
   end
-  def validate!(
+  def self.validate!(
     autocorrect: true,
     stage_changes: true,
     files: nil
@@ -269,7 +264,7 @@ module CodeOwnership
   # @note Leading newlines after the annotation are also removed to maintain clean formatting.
   #
   sig { params(filename: String).void }
-  def remove_file_annotation!(filename)
+  def self.remove_file_annotation!(filename)
     filepath = Pathname.new(filename)
 
     begin
@@ -292,24 +287,24 @@ module CodeOwnership
   # 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: [])
+  def self.for_backtrace(backtrace, 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: [])
+  def self.first_owned_file_for_backtrace(backtrace, 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)
+  sig { params(klass: T.nilable(T.any(T::Class[T.anything], T::Module[T.anything]))).returns(T.nilable(::CodeTeams::Team)) }
+  def self.for_class(klass)
     Private::TeamFinder.for_class(klass)
   end
 
   sig { params(package: Packs::Pack).returns(T.nilable(::CodeTeams::Team)) }
-  def for_package(package)
+  def self.for_package(package)
     Private::TeamFinder.for_package(package)
   end