code_ownership 1.32.7 → 1.32.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76d700471a2e895926f184939c856b08ac75d5240a0d924a8e4474ac733a7204
-  data.tar.gz: 3b62947009df98089b522614022643762c4c51d82af4f90f957606bcedfe60bc
+  metadata.gz: 71768f254f9fbb891679c002c16c20bd70a2125460e3c66995821cfe2784fe56
+  data.tar.gz: ce5698b1505d306026f807a142f648942ea06d3ab65576d05c623f6bdbdc1dfa
 SHA512:
-  metadata.gz: df833467c3721e6b7d67aebd0732d59c46073589210251bd0859cb05979103741876264dd336df10401005360bca7a2937c65e861044b22abd698a2b8b65a20d
-  data.tar.gz: 1b8f489aa18295cd8c534f3d5bcb3e2ab569553f26ec7e5a9445faff90da3aee3860bd3d7a02d6e91b80815d65b96680b0f54b085770ba85a54efa13aa0109b1
+  metadata.gz: 7b2e5da9f4e02b4db10c47be40b1b4bce33f7c44ad18797ff326a6e245f5dc57b2a8534c74fde74a1966970720a9bedf50d59858923e07f64d8e21d9f8411df1
+  data.tar.gz: b08f25b9008d86b19207931cb44c13adea814b998af8700b1fa445ad09e48e6549f86d6e4b75db41e5a783bf080ea5e25371d97db5307de8c5451bcd3d4fe3da

data/lib/code_ownership/cli.rb

@@ -61,7 +61,7 @@ module CodeOwnership
           File.exist?(file)
         end
       else
-        Private.tracked_files
+        nil
       end
 
       CodeOwnership.validate!(

data/lib/code_ownership/mapper.rb

@@ -40,15 +40,18 @@ module CodeOwnership
     #
     sig do
       abstract.params(files: T::Array[String]).
-        returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+        returns(T::Hash[String, ::CodeTeams::Team])
     end
-    def map_files_to_owners(files)
+    def globs_to_owner(files)
     end
 
+    #
+    # This should be fast when run with MANY files
+    #
     sig do
-      abstract.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+      abstract.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
     end
-    def codeowners_lines_to_owners
+    def update_cache(cache, files)
     end
 
     sig { abstract.returns(String) }
@@ -64,7 +67,7 @@ module CodeOwnership
       glob_to_owner_map_by_mapper_description = {}
 
       Mapper.all.each do |mapper|
-        mapped_files = mapper.codeowners_lines_to_owners
+        mapped_files = mapper.globs_to_owner(Private.tracked_files)
         mapped_files.each do |glob, owner|
           next if owner.nil?
           glob_to_owner_map_by_mapper_description[mapper.description] ||= {}

data/lib/code_ownership/private/codeowners_file.rb

@@ -90,6 +90,58 @@ module CodeOwnership
       def self.path
         Pathname.pwd.join('.github/CODEOWNERS')
       end
+
+      sig { params(files: T::Array[String]).void }
+      def self.update_cache!(files)
+        cache = Private.glob_cache
+        # Each mapper returns a new copy of the cache subset related to that mapper,
+        # which is then stored back into the cache.
+        Mapper.all.each do |mapper|
+          existing_cache = cache.raw_cache_contents.fetch(mapper.description, {})
+          updated_cache = mapper.update_cache(existing_cache, files)
+          cache.raw_cache_contents[mapper.description] = updated_cache
+        end
+      end
+
+      sig { returns(T::Boolean) }
+      def self.use_codeowners_cache?
+        CodeownersFile.path.exist? && !Private.configuration.skip_codeowners_validation
+      end
+
+      sig { returns(GlobCache) }
+      def self.to_glob_cache
+        github_team_to_code_team_map = T.let({}, T::Hash[String, CodeTeams::Team])
+        CodeTeams.all.each do |team|
+          github_team = TeamPlugins::Github.for(team).github.team
+          github_team_to_code_team_map[github_team] = team
+        end
+        raw_cache_contents = T.let({}, GlobCache::CacheShape)
+        current_mapper = T.let(nil, T.nilable(String))
+        mapper_descriptions = Set.new(Mapper.all.map(&:description))
+
+        path.readlines.each do |line|
+          line_with_no_comment = line.chomp.gsub("# ", "")
+          if mapper_descriptions.include?(line_with_no_comment)
+            current_mapper = line_with_no_comment
+          else
+            next if current_mapper.nil?
+            next if line.chomp == ""
+            # The codeowners file stores paths relative to the root of directory
+            # Since a `/` means root of the file system from the perspective of ruby,
+            # we remove that beginning slash so we can correctly glob the files out.
+            normalized_line = line.gsub(/^# /, '').gsub(/^\//, '')
+            split_line = normalized_line.split
+            # Most lines will be in the format: /path/to/file my-github-team
+            # This will skip over lines that are not of the correct form
+            next if split_line.count > 2
+            entry, github_team = split_line
+            raw_cache_contents[current_mapper] ||= {}
+            raw_cache_contents.fetch(current_mapper)[T.must(entry)] = github_team_to_code_team_map.fetch(T.must(github_team))
+          end
+        end
+
+        GlobCache.new(raw_cache_contents)
+      end
     end
   end
 end

data/lib/code_ownership/private/glob_cache.rb

@@ -7,19 +7,18 @@ module CodeOwnership
       extend T::Sig
 
       MapperDescription = T.type_alias { String }
-      GlobsByMapper = T.type_alias { T::Hash[String, CodeTeams::Team] }
 
       CacheShape = T.type_alias do
         T::Hash[
           MapperDescription,
-          GlobsByMapper
+          GlobsToOwningTeamMap
         ]
       end
 
       FilesByMapper = T.type_alias do
         T::Hash[
           String,
-          T::Array[MapperDescription]
+          T::Set[MapperDescription]
         ]
       end
 
@@ -33,6 +32,20 @@ module CodeOwnership
         @raw_cache_contents
       end
 
+      sig { params(files: T::Array[String]).returns(FilesByMapper) }
+      def mapper_descriptions_that_map_files(files)
+        if files.count > 100
+          # When looking at many files, expanding the cache out using Dir.glob and checking for intersections is faster
+          files_by_mappers = files.map{ |f| [f, Set.new([]) ]}.to_h
+          files_by_mappers.merge(files_by_mappers_via_expanded_cache)
+        else
+          # When looking at few files, using File.fnmatch is faster
+          files_by_mappers_via_file_fnmatch(files)
+        end
+      end
+
+      private
+
       sig { returns(CacheShape) }
       def expanded_cache
         @expanded_cache = T.let(@expanded_cache, T.nilable(CacheShape))
@@ -53,20 +66,45 @@ module CodeOwnership
       end
 
       sig { returns(FilesByMapper) }
-      def files_by_mapper
-        @files_by_mapper ||= T.let(@files_by_mapper, T.nilable(FilesByMapper))
-        @files_by_mapper ||= begin
-          files_by_mapper = {}
+      def files_by_mappers_via_expanded_cache
+        @files_by_mappers ||= T.let(@files_by_mappers, T.nilable(FilesByMapper))
+        @files_by_mappers ||= begin
+          files_by_mappers = T.let({}, FilesByMapper)
           expanded_cache.each do |mapper_description, file_by_owner|
             file_by_owner.each do |file, owner|
-              files_by_mapper[file] ||= []
-              files_by_mapper[file] << mapper_description
+              files_by_mappers[file] ||= Set.new([])
+              files_by_mappers.fetch(file) << mapper_description
             end
           end
 
-          files_by_mapper
+          files_by_mappers
         end
       end
+
+      sig { params(files: T::Array[String]).returns(FilesByMapper) }
+      def files_by_mappers_via_file_fnmatch(files)
+        files_by_mappers = T.let({}, FilesByMapper)
+
+        files.each do |file|
+          files_by_mappers[file] ||= Set.new([])
+          @raw_cache_contents.each do |mapper_description, globs_by_owner|
+            # As much as I'd like to *not* special case the file annotations mapper, using File.fnmatch? on the thousands of files mapped by the
+            # file annotations mapper is a lot of unnecessary extra work.
+            # Therefore we can just check if the file is in the globs directly for file annotations, otherwise use File.fnmatch
+            if mapper_description == OwnershipMappers::FileAnnotations::DESCRIPTION
+              files_by_mappers.fetch(file) << mapper_description if globs_by_owner[file]
+            else
+              globs_by_owner.each do |glob, owner|
+                if File.fnmatch?(glob, file, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+                  files_by_mappers.fetch(file) << mapper_description
+                end
+              end
+            end
+          end
+        end
+
+        files_by_mappers
+      end
     end
   end
 end

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

@@ -18,9 +18,10 @@ module CodeOwnership
         extend T::Sig
         include Mapper
 
-        @@map_files_to_owners = T.let({}, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
+        @@map_files_to_owners = T.let({}, T.nilable(T::Hash[String, ::CodeTeams::Team])) # rubocop:disable Style/ClassVars
 
         TEAM_PATTERN = T.let(/\A(?:#|\/\/) @team (?<team>.*)\Z/.freeze, Regexp)
+        DESCRIPTION = 'Annotations at the top of file'
 
         sig do
           override.params(file: String).
@@ -33,9 +34,9 @@ module CodeOwnership
         sig do
           override.
             params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+            returns(T::Hash[String, ::CodeTeams::Team])
         end
-        def map_files_to_owners(files)
+        def globs_to_owner(files)
           return @@map_files_to_owners if @@map_files_to_owners&.keys && @@map_files_to_owners.keys.count > 0
 
           @@map_files_to_owners = files.each_with_object({}) do |filename_relative_to_root, mapping| # rubocop:disable Style/ClassVars
@@ -46,6 +47,21 @@ module CodeOwnership
           end
         end
 
+        sig do
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
+        end
+        def update_cache(cache, files)
+          cache.merge!(globs_to_owner(files))
+          invalid_files = cache.keys.select do |file|
+            !Private.file_tracked?(file)
+          end
+          invalid_files.each do |invalid_file|
+            cache.delete(invalid_file)
+          end
+
+          cache
+        end
+
         sig { params(filename: String).returns(T.nilable(CodeTeams::Team)) }
         def file_annotation_based_owner(filename)
           # If for a directory is named with an ownable extension, we need to skip
@@ -96,17 +112,9 @@ module CodeOwnership
           end
         end
 
-        sig do
-          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
-        end
-        def codeowners_lines_to_owners
-          @@map_files_to_owners = nil # rubocop:disable Style/ClassVars
-          map_files_to_owners(Private.tracked_files)
-        end
-
         sig { override.returns(String) }
         def description
-          'Annotations at the top of file'
+          DESCRIPTION
         end
 
         sig { override.void }

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

@@ -24,20 +24,10 @@ module CodeOwnership
         end
 
         sig do
-          override.
-            params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
         end
-        def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
-          ParseJsPackages.all.each_with_object({}) do |package, res|
-            owner = owner_for_package(package)
-            next if owner.nil?
-
-            glob = package.directory.join('**/**').to_s
-            Dir.glob(glob).each do |path|
-              res[path] = owner
-            end
-          end
+        def update_cache(cache, files)
+          globs_to_owner(files)
         end
 
         #
@@ -49,9 +39,10 @@ module CodeOwnership
         # subset of files, but rather we want code ownership for all files.
         #
         sig do
-          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          override.params(files: T::Array[String]).
+            returns(T::Hash[String, ::CodeTeams::Team])
         end
-        def codeowners_lines_to_owners
+        def globs_to_owner(files)
           ParseJsPackages.all.each_with_object({}) do |package, res|
             owner = owner_for_package(package)
             next if owner.nil?

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

@@ -23,23 +23,6 @@ module CodeOwnership
           owner_for_package(package)
         end
 
-        sig do
-          override.
-            params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
-        end
-        def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
-          Packs.all.each_with_object({}) do |package, res|
-            owner = owner_for_package(package)
-            next if owner.nil?
-
-            glob = package.relative_path.join('**/**').to_s
-            Dir.glob(glob).each do |path|
-              res[path] = owner
-            end
-          end
-        end
-
         #
         # Package ownership ignores the passed in files when generating code owners lines.
         # This is because Package ownership knows that the fastest way to find code owners for package based ownership
@@ -49,9 +32,10 @@ module CodeOwnership
         # subset of files, but rather we want code ownership for all files.
         #
         sig do
-          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          override.params(files: T::Array[String]).
+            returns(T::Hash[String, ::CodeTeams::Team])
         end
-        def codeowners_lines_to_owners
+        def globs_to_owner(files)
           Packs.all.each_with_object({}) do |package, res|
             owner = owner_for_package(package)
             next if owner.nil?
@@ -65,6 +49,13 @@ module CodeOwnership
           'Owner metadata key in package.yml'
         end
 
+        sig do
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
+        end
+        def update_cache(cache, files)
+          globs_to_owner(files)
+        end
+
         sig { params(package: Packs::Pack).returns(T.nilable(CodeTeams::Team)) }
         def owner_for_package(package)
           raw_owner_value = package.metadata['owner']

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

@@ -10,15 +10,14 @@ module CodeOwnership
         include Mapper
         include Validator
 
-        @@map_files_to_owners = T.let(@map_files_to_owners, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
+        @@map_files_to_owners = T.let(@map_files_to_owners, T.nilable(T::Hash[String, ::CodeTeams::Team])) # rubocop:disable Style/ClassVars
         @@map_files_to_owners = {} # rubocop:disable Style/ClassVars
-        @@codeowners_lines_to_owners = T.let(@codeowners_lines_to_owners, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
+        @@codeowners_lines_to_owners = T.let(@codeowners_lines_to_owners, T.nilable(T::Hash[String, ::CodeTeams::Team])) # rubocop:disable Style/ClassVars
         @@codeowners_lines_to_owners = {} # rubocop:disable Style/ClassVars
 
         sig do
-          override.
-            params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          params(files: T::Array[String]).
+          returns(T::Hash[String, ::CodeTeams::Team])
         end
         def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
           return @@map_files_to_owners if @@map_files_to_owners&.keys && @@map_files_to_owners.keys.count > 0
@@ -93,9 +92,17 @@ module CodeOwnership
         end
 
         sig do
-          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
         end
-        def codeowners_lines_to_owners
+        def update_cache(cache, files)
+          globs_to_owner(files)
+        end
+
+        sig do
+          override.params(files: T::Array[String]).
+            returns(T::Hash[String, ::CodeTeams::Team])
+        end
+        def globs_to_owner(files)
           return @@codeowners_lines_to_owners if @@codeowners_lines_to_owners&.keys && @@codeowners_lines_to_owners.keys.count > 0
 
           @@codeowners_lines_to_owners = CodeTeams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars

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

@@ -9,15 +9,14 @@ module CodeOwnership
         extend T::Sig
         include Mapper
 
-        @@map_files_to_owners = T.let(@map_files_to_owners, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
+        @@map_files_to_owners = T.let(@map_files_to_owners, T.nilable(T::Hash[String, ::CodeTeams::Team])) # rubocop:disable Style/ClassVars
         @@map_files_to_owners = {} # rubocop:disable Style/ClassVars
-        @@codeowners_lines_to_owners = T.let(@codeowners_lines_to_owners, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
+        @@codeowners_lines_to_owners = T.let(@codeowners_lines_to_owners, T.nilable(T::Hash[String, ::CodeTeams::Team])) # rubocop:disable Style/ClassVars
         @@codeowners_lines_to_owners = {} # rubocop:disable Style/ClassVars
 
         sig do
-          override.
-            params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          params(files: T::Array[String]).
+          returns(T::Hash[String, ::CodeTeams::Team])
         end
         def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
           return @@map_files_to_owners if @@map_files_to_owners&.keys && @@map_files_to_owners.keys.count > 0
@@ -36,9 +35,10 @@ module CodeOwnership
         end
 
         sig do
-          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
+          override.params(files: T::Array[String]).
+            returns(T::Hash[String, ::CodeTeams::Team])
         end
-        def codeowners_lines_to_owners
+        def globs_to_owner(files)
           return @@codeowners_lines_to_owners if @@codeowners_lines_to_owners&.keys && @@codeowners_lines_to_owners.keys.count > 0
 
           @@codeowners_lines_to_owners = CodeTeams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars
@@ -52,6 +52,13 @@ module CodeOwnership
           @@map_files_to_owners = {} # rubocop:disable Style/ClassVars
         end
 
+        sig do
+          override.params(cache: GlobsToOwningTeamMap, files: T::Array[String]).returns(GlobsToOwningTeamMap)
+        end
+        def update_cache(cache, files)
+          globs_to_owner(files)
+        end
+
         sig { override.returns(String) }
         def description
           'Team YML ownership'

data/lib/code_ownership/private/validations/files_have_owners.rb

@@ -10,10 +10,10 @@ module CodeOwnership
 
         sig { override.params(files: T::Array[String], autocorrect: T::Boolean, stage_changes: T::Boolean).returns(T::Array[String]) }
         def validation_errors(files:, autocorrect: true, stage_changes: true)
-          files_by_mapper = Private.glob_cache.files_by_mapper
-
-          files_not_mapped_at_all = files.select do |file|
-            files_by_mapper.fetch(file, []).count == 0
+          cache = Private.glob_cache
+          file_mappings = cache.mapper_descriptions_that_map_files(files)
+          files_not_mapped_at_all = file_mappings.select do |file, mapper_descriptions|
+            mapper_descriptions.count == 0
           end
 
           errors = T.let([], T::Array[String])
@@ -22,7 +22,7 @@ module CodeOwnership
             errors << <<~MSG
               Some files are missing ownership:
 
-              #{files_not_mapped_at_all.map { |file| "- #{file}" }.join("\n")}
+              #{files_not_mapped_at_all.map { |file, mappers| "- #{file}" }.join("\n")}
             MSG
           end
 

data/lib/code_ownership/private/validations/files_have_unique_owners.rb

@@ -10,14 +10,10 @@ module CodeOwnership
 
         sig { override.params(files: T::Array[String], autocorrect: T::Boolean, stage_changes: T::Boolean).returns(T::Array[String]) }
         def validation_errors(files:, autocorrect: true, stage_changes: true)
-          files_by_mapper = Private.glob_cache.files_by_mapper
-
-          files_mapped_by_multiple_mappers = {}
-          files.each do |file|
-            mappers = files_by_mapper.fetch(file, [])
-            if mappers.count > 1
-              files_mapped_by_multiple_mappers[file] = mappers
-            end
+          cache = Private.glob_cache
+          file_mappings = cache.mapper_descriptions_that_map_files(files)
+          files_mapped_by_multiple_mappers = file_mappings.select do |file, mapper_descriptions|
+            mapper_descriptions.count > 1
           end
 
           errors = T.let([], T::Array[String])
@@ -26,7 +22,7 @@ module CodeOwnership
             errors << <<~MSG
               Code ownership should only be defined for each file in one way. The following files have declared ownership in multiple ways.
 
-              #{files_mapped_by_multiple_mappers.map { |file, descriptions| "- #{file} (#{descriptions.join(', ')})" }.join("\n")}
+              #{files_mapped_by_multiple_mappers.map { |file, descriptions| "- #{file} (#{descriptions.to_a.join(', ')})" }.join("\n")}
             MSG
           end
 

data/lib/code_ownership/private.rb

@@ -44,6 +44,8 @@ module CodeOwnership
 
     sig { params(files: T::Array[String], autocorrect: T::Boolean, stage_changes: T::Boolean).void }
     def self.validate!(files:, autocorrect: true, stage_changes: true)
+      CodeownersFile.update_cache!(files) if CodeownersFile.use_codeowners_cache?
+
       errors = Validator.all.flat_map do |validator|
         validator.validation_errors(
           files: files,
@@ -79,6 +81,24 @@ module CodeOwnership
       @tracked_files ||= Dir.glob(configuration.owned_globs) - Dir.glob(configuration.unowned_globs)
     end
 
+    sig { params(file: String).returns(T::Boolean) }
+    def self.file_tracked?(file)
+      # Another way to accomplish this is
+      # (Dir.glob(configuration.owned_globs) - Dir.glob(configuration.unowned_globs)).include?(file)
+      # However, globbing out can take 5 or more seconds on a large repository, dramatically slowing down
+      # invocations to `bin/codeownership validate --diff`.
+      # Using `File.fnmatch?` is a lot faster!
+      in_owned_globs = configuration.owned_globs.all? do |owned_glob|
+        File.fnmatch?(owned_glob, file, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+
+      in_unowned_globs = configuration.unowned_globs.all? do |unowned_glob|
+        File.fnmatch?(unowned_glob, file, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+
+      in_owned_globs && !in_unowned_globs
+    end
+
     sig { params(team_name: String, location_of_reference: String).returns(CodeTeams::Team) }
     def self.find_team!(team_name, location_of_reference)
       found_team = CodeTeams.find(team_name)
@@ -92,7 +112,13 @@ module CodeOwnership
     sig { returns(GlobCache) }
     def self.glob_cache
       @glob_cache ||= T.let(@glob_cache, T.nilable(GlobCache))
-      @glob_cache ||= Mapper.to_glob_cache
+      @glob_cache ||= begin
+        if CodeownersFile.use_codeowners_cache?
+          CodeownersFile.to_glob_cache
+        else
+          Mapper.to_glob_cache
+        end
+      end
     end
   end
 

data/lib/code_ownership.rb

@@ -19,6 +19,7 @@ module CodeOwnership
   extend T::Helpers
 
   requires_ancestor { Kernel }
+  GlobsToOwningTeamMap = T.type_alias { T::Hash[String, CodeTeams::Team] }
 
   sig { params(file: String).returns(T.nilable(CodeTeams::Team)) }
   def for_file(file)
@@ -50,7 +51,7 @@ module CodeOwnership
     ownership_information << "# Code Ownership Report for `#{team.name}` Team"
     Mapper.all.each do |mapper|
       ownership_information << "## #{mapper.description}"
-      codeowners_lines = mapper.codeowners_lines_to_owners
+      codeowners_lines = mapper.globs_to_owner(Private.tracked_files)
       ownership_for_mapper = []
       codeowners_lines.each do |line, team_for_line|
         next if team_for_line.nil?
@@ -81,18 +82,24 @@ module CodeOwnership
 
   sig do
     params(
-      files: T::Array[String],
       autocorrect: T::Boolean,
-      stage_changes: T::Boolean
+      stage_changes: T::Boolean,
+      files: T.nilable(T::Array[String]),
     ).void
   end
   def validate!(
-    files: Private.tracked_files,
     autocorrect: true,
-    stage_changes: true
+    stage_changes: true,
+    files: nil
   )
     Private.load_configuration!
-    tracked_file_subset = Private.tracked_files & files
+
+    tracked_file_subset = if files
+      files.select{|f| Private.file_tracked?(f)}
+    else
+      Private.tracked_files
+    end
+
     Private.validate!(files: tracked_file_subset, autocorrect: autocorrect, stage_changes: stage_changes)
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: code_ownership
 version: !ruby/object:Gem::Version
-  version: 1.32.7
+  version: 1.32.9
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-11 00:00:00.000000000 Z
+date: 2023-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams