code_ownership 1.33.1 → 1.34.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: db417ae94561fc36906b23a65105d40bb48c6a084ae79fa33f49a84a903344f1
-  data.tar.gz: b0ba72d4cfd3f5c34e90352f1c009fd3e9093cea73f6a7b5044e6ae4632040c7
+  metadata.gz: 5b59593095e1b124a7e6bf7b929e7f2bc9ab61f65f5f0867fff88b6cf2b5e097
+  data.tar.gz: 1dcef45327a13811dacbe44566dbddae71998145de1b9ca63df5814e848ca899
 SHA512:
-  metadata.gz: 24b6290597a69fd80b62a70a0268dc559a8704f12f67800aa5640ed71d3af6c57b551f7fc757ea57a92503cc5cca89556872b13159bf13dfaef06b868dd51e09
-  data.tar.gz: 28ad95acd3dcba5b2b94577a6b8355bd4d78b044cd96c7c608a9ece82a89bd4c0792143503b29d4a3ca81a0b0c71fb57427c3c1ca684a0ba31cbc0a5cb4f541b
+  metadata.gz: 05546e3fb45286c44cc7227675b01d747ada9ee9b5e8cb02ab692fe3b9e30558fd1d8cfbc6716fadbece2c4048d164fe9a00b940a80f7fdf4366dbf0043fcbdf
+  data.tar.gz: '06584d3cb45cfb7ab7cd8e0e55a1a4b1c5db09e0dc022300f75f63714a2121f42301fe9bdbe11c1f5715909a7853d68060244be51925d0edb1fab0985b0112e5'

data/README.md

@@ -12,6 +12,18 @@ There is also a [companion VSCode Extension]([url](https://github.com/rubyatscal
 
 There are three ways to declare code ownership using this gem.
 
+### Directory-Based Ownership
+Directory based ownership allows for all files in that directory and all its sub-directories to be owned by one team. To define this, add a `.codeowner` file inside that directory with the name of the team as the contents of that file.
+```
+Team
+```
+
+### File-Annotation Based Ownership
+File annotations are a last resort if there is no clear home for your code. File annotations go at the top of your file, and look like this:
+```ruby
+# @team MyTeam
+```
+
 ### Package-Based Ownership
 Package based ownership integrates [`packwerk`](https://github.com/Shopify/packwerk) and has ownership defined per package. To define that all files within a package are owned by one team, configure your `package.yml` like this:
 ```yml
@@ -38,11 +50,6 @@ owned_globs:
   - app/services/stuff_belonging_to_my_team/**/**
   - app/controllers/other_stuff_belonging_to_my_team/**/**
 ```
-### File-Annotation Based Ownership
-File annotations are a last resort if there is no clear home for your code. File annotations go at the top of your file, and look like this:
-```ruby
-# @team MyTeam
-```
 
 ### Javascript Package Ownership
 Javascript package based ownership allows you to specify an ownership key in a `package.json`. To use this, configure your `package.json` like this:

data/lib/code_ownership/private/ownership_mappers/directory_ownership.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+# typed: true
+
+module CodeOwnership
+  module Private
+    module OwnershipMappers
+      class DirectoryOwnership
+        extend T::Sig
+        include Mapper
+
+        CODEOWNERS_DIRECTORY_FILE_NAME = '.codeowner'
+
+        @@directory_cache = T.let({}, T::Hash[String, T.nilable(CodeTeams::Team)]) # rubocop:disable Style/ClassVars
+
+        sig do
+          override.params(file: String).
+            returns(T.nilable(::CodeTeams::Team))
+        end
+        def map_file_to_owner(file)
+          map_file_to_relevant_owner(file)
+        end
+
+        sig do
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
+        end
+        def update_cache(cache, files)
+          globs_to_owner(files)
+        end
+
+        #
+        # Directory ownership ignores the passed in files when generating code owners lines.
+        # This is because Directory ownership knows that the fastest way to find code owners for directory based ownership
+        # is to simply iterate over the directories and grab the owner, rather than iterating over each file just to get what directory it is in
+        # In theory this means that we may generate code owners lines that cover files that are not in the passed in argument,
+        # but in practice this is not of consequence because in reality we never really want to generate code owners for only a
+        # subset of files, but rather we want code ownership for all files.
+        #
+        sig do
+          override.params(files: T::Array[String]).
+            returns(T::Hash[String, ::CodeTeams::Team])
+        end
+        def globs_to_owner(files)
+          # The T.unsafe is because the upstream RBI is wrong for Pathname.glob
+          T
+            .unsafe(Pathname)
+            .glob(File.join('**/', CODEOWNERS_DIRECTORY_FILE_NAME))
+            .map(&:cleanpath)
+            .each_with_object({}) do |pathname, res|
+            owner = owner_for_codeowners_file(pathname)
+            res[pathname.dirname.cleanpath.join('**/**').to_s] = owner
+          end
+        end
+
+        sig { override.returns(String) }
+        def description
+          'Owner in .codeowner'
+        end
+
+        sig { override.void }
+        def bust_caches!
+          @@directory_cache = {} # rubocop:disable Style/ClassVars
+        end
+
+        private
+
+        sig { params(codeowners_file: Pathname).returns(CodeTeams::Team) }
+        def owner_for_codeowners_file(codeowners_file)
+          raw_owner_value = File.foreach(codeowners_file).first.strip
+
+          Private.find_team!(
+            raw_owner_value,
+            codeowners_file.to_s
+          )
+        end
+
+        # takes a file and finds the relevant `.codeowner` file by walking up the directory
+        # structure. Example, given `a/b/c.rb`, this looks for `a/b/.codeowner`, `a/.codeowner`,
+        # and `.codeowner` in that order, stopping at the first file to actually exist.
+        # We do additional caching so that we don't have to check for file existence every time
+        sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
+        def map_file_to_relevant_owner(file)
+          file_path = Pathname.new(file)
+          path_components = file_path.each_filename.to_a.map { |path| Pathname.new(path) }
+
+          (path_components.length - 1).downto(0).each do |i|
+            potential_relative_path_name = T.must(path_components[0...i]).reduce(Pathname.new('')) { |built_path, path| built_path.join(path) }
+            potential_codeowners_file = potential_relative_path_name.join(CODEOWNERS_DIRECTORY_FILE_NAME)
+
+            potential_codeowners_file_name = potential_codeowners_file.to_s
+
+            team = nil
+            if @@directory_cache.key?(potential_codeowners_file_name)
+              team = @@directory_cache[potential_codeowners_file_name]
+            elsif potential_codeowners_file.exist?
+              team = owner_for_codeowners_file(potential_codeowners_file)
+
+              @@directory_cache[potential_codeowners_file_name] = team
+            else
+              @@directory_cache[potential_codeowners_file_name] = nil
+            end
+
+            return team unless team.nil?
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/code_ownership/private.rb

@@ -13,6 +13,7 @@ require 'code_ownership/private/validations/github_codeowners_up_to_date'
 require 'code_ownership/private/validations/files_have_unique_owners'
 require 'code_ownership/private/ownership_mappers/file_annotations'
 require 'code_ownership/private/ownership_mappers/team_globs'
+require 'code_ownership/private/ownership_mappers/directory_ownership'
 require 'code_ownership/private/ownership_mappers/package_ownership'
 require 'code_ownership/private/ownership_mappers/js_package_ownership'
 require 'code_ownership/private/ownership_mappers/team_yml_ownership'
@@ -62,7 +63,7 @@ module CodeOwnership
 
     # Returns a string version of the relative path to a Rails constant,
     # or nil if it can't find something
-    sig { params(klass: T.nilable(T.any(Class, Module))).returns(T.nilable(String)) }
+    sig { params(klass: T.nilable(T.any(T::Class[T.anything], Module))).returns(T.nilable(String)) }
     def self.path_from_klass(klass)
       if klass
         path = Object.const_source_location(klass.to_s)&.first

data/lib/code_ownership.rb

@@ -156,7 +156,7 @@ module CodeOwnership
   end
   private_class_method(:backtrace_with_ownership)
 
-  sig { params(klass: T.nilable(T.any(Class, Module))).returns(T.nilable(::CodeTeams::Team)) }
+  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 ||= {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_ownership
 version: !ruby/object:Gem::Version
-  version: 1.33.1
+  version: 1.34.1
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-06-30 00:00:00.000000000 Z
+date: 2023-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -168,6 +168,7 @@ files:
 - lib/code_ownership/private/codeowners_file.rb
 - lib/code_ownership/private/extension_loader.rb
 - lib/code_ownership/private/glob_cache.rb
+- lib/code_ownership/private/ownership_mappers/directory_ownership.rb
 - lib/code_ownership/private/ownership_mappers/file_annotations.rb
 - lib/code_ownership/private/ownership_mappers/js_package_ownership.rb
 - lib/code_ownership/private/ownership_mappers/package_ownership.rb