code_ownership 1.26.0 → 1.28.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 988c067afbabcc65d5b697aea162ba1c288787e4d7d9a84a261b00f76859aa6b
-  data.tar.gz: 6a504214d4470cfd2d1ab103f201069367e39962a390d34382410587a6067e40
+  metadata.gz: bf48240fd31979132287823a3f9d40d6b03776df405583c31a56cb87e6dfbe40
+  data.tar.gz: 1cbd9b0fee826c7a23dd71335043eab358f99157bb7f677a94b8d4abc1782f4e
 SHA512:
-  metadata.gz: 16b3e48c3cb734857dd66cf03f9d43d89bb92ee3ab92abfc0550004274531e03eef4abc9157fab33e25d815dd5b5c6f055d65987e7526dcb4952212930935678
-  data.tar.gz: 0f0cc9f4a1b8938e088bc258d5b247d633beaac3c68ddf37ea269fa3740d27d796b9773354e47855e79ecd5e958b49d97fd9f231f42502e62eab508d1d8ea9a1
+  metadata.gz: 68721e648bcd3e8888f3f94d33baf0d38b642c3d6104db0964e6aff3194860407e72c9ad88ffec357285006bff87490b49b92a238fbbf83d37509d34868ea0fe
+  data.tar.gz: 0d878620986f0fe3e6168fa8ea0db1a1a530d27c0f35410f70b3f876146df2b184f9db3486ef9e4e74c0583a067b48ad4462af6877d7452e5d1574bec61ebd8f

data/README.md

@@ -1,14 +1,17 @@
 # CodeOwnership
-This gem helps engineering teams declare ownership of code.
 
-Check out `lib/code_ownership.rb` to see the public API.
+This gem helps engineering teams declare ownership of code. This gem works best in large, usually monolithic code bases where many teams work together.
 
-Check out `code_ownership_spec.rb` to see examples of how code ownership is used.
+Check out [`lib/code_ownership.rb`](https://github.com/rubyatscale/code_ownership/blob/main/lib/code_ownership.rb) to see the public API.
 
-There is also a [companion VSCode Extension]([url](https://github.com/bigrails/code-ownership-vscode)) for this gem. Just search `Gusto.code-ownership-vscode` in the VSCode Extension Marketplace.
+Check out [`code_ownership_spec.rb`](https://github.com/rubyatscale/code_ownership/blob/main/spec/lib/code_ownership_spec.rb) to see examples of how code ownership is used.
+
+There is also a [companion VSCode Extension]([url](https://github.com/rubyatscale/code-ownership-vscode)) for this gem. Just search `Gusto.code-ownership-vscode` in the VSCode Extension Marketplace.
 
 ## Usage: Declaring Ownership
+
 There are three ways to declare code ownership using this gem.
+
 ### 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
@@ -19,7 +22,7 @@ metadata:
 ```
 
 ### Glob-Based Ownership
-In your team's configured YML (see [`bigrails-teams`](https://github.com/bigrails/bigrails-teams)), you can set `owned_globs` to be a glob of files your team owns. For example, in `my_team.yml`:
+In your team's configured YML (see [`code_teams`](https://github.com/rubyatscale/code_teams)), you can set `owned_globs` to be a glob of files your team owns. For example, in `my_team.yml`:
 ```yml
 name: My Team
 owned_globs:
@@ -31,9 +34,32 @@ File annotations are a last resort if there is no clear home for your code. File
 ```ruby
 # @team MyTeam
 ```
+
+### Javascript Package Ownership
+Javascript package based ownership allows you to specify an owenrship key in a `package.json`. To use this, configure your `package.json` like this:
+
+```json
+{
+  // other keys
+  "metadata": {
+    "owner": "My Team"
+  }
+  // other keys
+}
+```
+
+You can also tell `code_ownership` where to find JS packages in the configuration, like this:
+```yml
+js_package_paths:
+  - frontend/javascripts/packages/*
+  - frontend/other_location_for_packages/*
+```
+
+This defaults `**/`, which makes it look for `package.json` files across your application.
+
 ## Usage: Reading CodeOwnership
 ### `for_file`
-`CodeOwnership.for_file`, given a relative path to a file returns a `Teams::Team` if there is a team that owns the file, `nil` otherwise.
+`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.
 
 ```ruby
 CodeOwnership.for_file('path/to/file/relative/to/application/root.rb')
@@ -44,7 +70,7 @@ Contributor note: If you are making updates to this method or the methods gettin
 See `code_ownership_spec.rb` for examples.
 
 ### `for_backtrace`
-`CodeOwnership.for_backtrace` can be given a backtrace and will either return `nil`, or a `Teams::Team`.
+`CodeOwnership.for_backtrace` can be given a backtrace and will either return `nil`, or a `CodeTeams::Team`.
 
 ```ruby
 CodeOwnership.for_backtrace(exception.backtrace)
@@ -56,7 +82,7 @@ See `code_ownership_spec.rb` for an example.
 
 ### `for_class`
 
-`CodeOwnership.for_class` can be given a class and will either return `nil`, or a `Teams::Team`.
+`CodeOwnership.for_class` can be given a class and will either return `nil`, or a `CodeTeams::Team`.
 
 ```ruby
 CodeOwnership.for_class(MyClass.name)
@@ -71,9 +97,11 @@ See `code_ownership_spec.rb` for an example.
 A `CODEOWNERS` file defines who owns specific files or paths in a repository. When you run `bin/codeownership validate`, a `.github/CODEOWNERS` file will automatically be generated and updated.
 
 ## Proper Configuration & Validation
+
 CodeOwnership comes with a validation function to ensure the following things are true:
+
 1) Only one mechanism is defining file ownership. That is -- you can't have a file annotation on a file owned via package-based or glob-based ownership. This helps make ownership behavior more clear by avoiding concerns about precedence.
-2) All teams referenced as an owner for any file or package is a valid team (i.e. it's in the list of `Teams.all`).
+2) All teams referenced as an owner for any file or package is a valid team (i.e. it's in the list of `CodeTeams.all`).
 3) All files have ownership. You can specify in `unowned_globs` to represent a TODO list of files to add ownership to.
 3) The `.github/CODEOWNERS` file is up to date. This is automatically corrected and staged unless specified otherwise with `bin/codeownership validate --skip-autocorrect --skip-stage`. You can turn this validation off by setting `skip_codeowners_validation: true` in `code_ownership.yml`.
 

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

@@ -18,13 +18,13 @@ module CodeOwnership
         extend T::Sig
         include Interface
 
-        @@map_files_to_owners = T.let({}, T.nilable(T::Hash[String, T.nilable(::Teams::Team)])) # rubocop:disable Style/ClassVars
+        @@map_files_to_owners = T.let({}, T.nilable(T::Hash[String, T.nilable(::CodeTeams::Team)])) # rubocop:disable Style/ClassVars
 
         TEAM_PATTERN = T.let(/\A(?:#|\/\/) @team (?<team>.*)\Z/.freeze, Regexp)
 
         sig do
           override.params(file: String).
-            returns(T.nilable(::Teams::Team))
+            returns(T.nilable(::CodeTeams::Team))
         end
         def map_file_to_owner(file)
           file_annotation_based_owner(file)
@@ -33,7 +33,7 @@ module CodeOwnership
         sig do
           override.
             params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::Teams::Team)])
+            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def map_files_to_owners(files)
           return @@map_files_to_owners if @@map_files_to_owners&.keys && @@map_files_to_owners.keys.count > 0
@@ -46,7 +46,7 @@ module CodeOwnership
           end
         end
 
-        sig { params(filename: String).returns(T.nilable(Teams::Team)) }
+        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
           # so File.foreach doesn't blow up below. This was needed because Cypress
@@ -97,7 +97,7 @@ module CodeOwnership
         end
 
         sig do
-          override.returns(T::Hash[String, T.nilable(::Teams::Team)])
+          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def codeowners_lines_to_owners
           @@map_files_to_owners = nil # rubocop:disable Style/ClassVars

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

@@ -16,7 +16,7 @@ module CodeOwnership
         #
         sig do
           abstract.params(file: String).
-            returns(T.nilable(::Teams::Team))
+            returns(T.nilable(::CodeTeams::Team))
         end
         def map_file_to_owner(file)
         end
@@ -26,13 +26,13 @@ module CodeOwnership
         #
         sig do
           abstract.params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::Teams::Team)])
+            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def map_files_to_owners(files)
         end
 
         sig do
-          abstract.returns(T::Hash[String, T.nilable(::Teams::Team)])
+          abstract.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def codeowners_lines_to_owners
         end

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

@@ -13,7 +13,7 @@ module CodeOwnership
 
         sig do
           override.params(file: String).
-            returns(T.nilable(::Teams::Team))
+            returns(T.nilable(::CodeTeams::Team))
         end
         def map_file_to_owner(file)
           package = map_file_to_relevant_package(file)
@@ -26,7 +26,7 @@ module CodeOwnership
         sig do
           override.
             params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::Teams::Team)])
+            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
           ParseJsPackages.all.each_with_object({}) do |package, res|
@@ -49,7 +49,7 @@ module CodeOwnership
         # subset of files, but rather we want code ownership for all files.
         #
         sig do
-          override.returns(T::Hash[String, T.nilable(::Teams::Team)])
+          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def codeowners_lines_to_owners
           ParseJsPackages.all.each_with_object({}) do |package, res|
@@ -65,7 +65,7 @@ module CodeOwnership
           'Owner metadata key in package.json'
         end
 
-        sig { params(package: ParseJsPackages::Package).returns(T.nilable(Teams::Team)) }
+        sig { params(package: ParseJsPackages::Package).returns(T.nilable(CodeTeams::Team)) }
         def owner_for_package(package)
           raw_owner_value = package.metadata['owner']
           return nil if !raw_owner_value

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

@@ -13,10 +13,10 @@ module CodeOwnership
 
         sig do
           override.params(file: String).
-            returns(T.nilable(::Teams::Team))
+            returns(T.nilable(::CodeTeams::Team))
         end
         def map_file_to_owner(file)
-          package = map_file_to_relevant_package(file)
+          package = ParsePackwerk.package_from_path(file)
 
           return nil if package.nil?
 
@@ -26,7 +26,7 @@ module CodeOwnership
         sig do
           override.
             params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::Teams::Team)])
+            returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def map_files_to_owners(files) # rubocop:disable Lint/UnusedMethodArgument
           ParsePackwerk.all.each_with_object({}) do |package, res|
@@ -49,7 +49,7 @@ module CodeOwnership
         # subset of files, but rather we want code ownership for all files.
         #
         sig do
-          override.returns(T::Hash[String, T.nilable(::Teams::Team)])
+          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def codeowners_lines_to_owners
           ParsePackwerk.all.each_with_object({}) do |package, res|
@@ -65,7 +65,7 @@ module CodeOwnership
           'Owner metadata key in package.yml'
         end
 
-        sig { params(package: ParsePackwerk::Package).returns(T.nilable(Teams::Team)) }
+        sig { params(package: ParsePackwerk::Package).returns(T.nilable(CodeTeams::Team)) }
         def owner_for_package(package)
           raw_owner_value = package.metadata['owner']
           return nil if !raw_owner_value
@@ -80,41 +80,6 @@ module CodeOwnership
         def bust_caches!
           @@package_yml_cache = {} # rubocop:disable Style/ClassVars
         end
-
-        private
-
-        # takes a file and finds the relevant `package.yml` file by walking up the directory
-        # structure. Example, given `packs/a/b/c.rb`, this looks for `packs/a/b/package.yml`, `packs/a/package.yml`,
-        # `packs/package.yml`, and `package.yml` 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(ParsePackwerk::Package)) }
-        def map_file_to_relevant_package(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_package_yml_path = potential_relative_path_name.
-              join(ParsePackwerk::PACKAGE_YML_NAME)
-
-            potential_package_yml_string = potential_package_yml_path.to_s
-
-            package = nil
-            if @@package_yml_cache.key?(potential_package_yml_string)
-              package = @@package_yml_cache[potential_package_yml_string]
-            elsif potential_package_yml_path.exist?
-              package = ParsePackwerk::Package.from(potential_package_yml_path)
-
-              @@package_yml_cache[potential_package_yml_string] = package
-            else
-              @@package_yml_cache[potential_package_yml_string] = nil
-            end
-
-            return package unless package.nil?
-          end
-
-          nil
-        end
       end
     end
   end

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

@@ -9,20 +9,20 @@ module CodeOwnership
         extend T::Sig
         include Interface
 
-        @@map_files_to_owners = T.let(@map_files_to_owners, T.nilable(T::Hash[String, T.nilable(::Teams::Team)])) # rubocop:disable Style/ClassVars
+        @@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 = {} # rubocop:disable Style/ClassVars
-        @@codeowners_lines_to_owners = T.let(@codeowners_lines_to_owners, T.nilable(T::Hash[String, T.nilable(::Teams::Team)])) # 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 = {} # rubocop:disable Style/ClassVars
 
         sig do
           override.
             params(files: T::Array[String]).
-            returns(T::Hash[String, T.nilable(::Teams::Team)])
+            returns(T::Hash[String, T.nilable(::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
 
-          @@map_files_to_owners = Teams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars
+          @@map_files_to_owners = CodeTeams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars
             TeamPlugins::Ownership.for(team).owned_globs.each do |glob|
               Dir.glob(glob).each do |filename|
                 map[filename] = team
@@ -33,19 +33,19 @@ module CodeOwnership
 
         sig do
           override.params(file: String).
-            returns(T.nilable(::Teams::Team))
+            returns(T.nilable(::CodeTeams::Team))
         end
         def map_file_to_owner(file)
           map_files_to_owners([file])[file]
         end
 
         sig do
-          override.returns(T::Hash[String, T.nilable(::Teams::Team)])
+          override.returns(T::Hash[String, T.nilable(::CodeTeams::Team)])
         end
         def codeowners_lines_to_owners
           return @@codeowners_lines_to_owners if @@codeowners_lines_to_owners&.keys && @@codeowners_lines_to_owners.keys.count > 0
 
-          @@codeowners_lines_to_owners = Teams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars
+          @@codeowners_lines_to_owners = CodeTeams.all.each_with_object({}) do |team, map| # rubocop:disable Style/ClassVars
             TeamPlugins::Ownership.for(team).owned_globs.each do |owned_glob|
               map[owned_glob] = team
             end

data/lib/code_ownership/private/parse_js_packages.rb

@@ -32,6 +32,16 @@ module CodeOwnership
             name: package_name,
             metadata: package_loaded_json[METADATA] || {}
           )
+        rescue JSON::ParserError => e
+          error_message = <<~MESSAGE
+            #{e.inspect}
+
+            #{pathname} has invalid JSON, so code ownership cannot be determined.
+
+            Please either make the JSON in that file valid or specify `js_package_paths` in config/code_ownership.yml.
+          MESSAGE
+
+          raise InvalidCodeOwnershipConfigurationError.new(error_message)
         end
 
         sig { returns(Pathname) }

data/lib/code_ownership/private/team_plugins/github.rb

@@ -3,7 +3,7 @@
 module CodeOwnership
   module Private
     module TeamPlugins
-      class Github < Teams::Plugin
+      class Github < CodeTeams::Plugin
         extend T::Sig
         extend T::Helpers
 

data/lib/code_ownership/private/team_plugins/ownership.rb

@@ -3,7 +3,7 @@
 module CodeOwnership
   module Private
     module TeamPlugins
-      class Ownership < Teams::Plugin
+      class Ownership < CodeTeams::Plugin
         extend T::Sig
         extend T::Helpers
 

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

@@ -25,24 +25,66 @@ module CodeOwnership
             # https://help.github.com/en/articles/about-code-owners
           HEADER
 
-          contents = [
-            header,
+          expected_content_lines = [
+            *header.split("\n"),
+            nil, # For line between header and codeowners_file_lines
             *codeowners_file_lines,
             nil, # For end-of-file newline
-          ].join("\n")
+          ]
+          
+          expected_contents = expected_content_lines.join("\n")
+          actual_contents = codeowners_filepath.exist? ? codeowners_filepath.read : ""
+          actual_content_lines = actual_contents.split("\n")
 
-          codeowners_up_to_date = codeowners_filepath.exist? && codeowners_filepath.read == contents
+          codeowners_up_to_date = actual_contents == expected_contents
 
           errors = T.let([], T::Array[String])
 
           if !codeowners_up_to_date
             if autocorrect
-              codeowners_filepath.write(contents)
+              codeowners_filepath.write(expected_contents)
               if stage_changes
                 `git add #{codeowners_filepath}`
               end
             else
-              errors << "CODEOWNERS out of date. Ensure pre-commit hook is set up correctly and used. You can also run bin/codeownership validate to update the CODEOWNERS file\n"
+              # If there is no current file or its empty, display a shorter message.
+              missing_lines = expected_content_lines - actual_content_lines
+              extra_lines = actual_content_lines - expected_content_lines
+              missing_lines_text = if missing_lines.any?
+                <<~COMMENT
+                  CODEOWNERS should contain the following lines, but does not:
+                  #{(expected_content_lines - actual_content_lines).map { |line| "- \"#{line}\""}.join("\n")}
+                COMMENT
+              end
+
+              extra_lines_text = if extra_lines.any?
+                <<~COMMENT
+                  CODEOWNERS should not contain the following lines, but it does:
+                  #{(actual_content_lines - expected_content_lines).map { |line| "- \"#{line}\""}.join("\n")}
+                COMMENT
+              end
+
+              diff_text = if missing_lines_text && extra_lines_text
+                 "#{missing_lines_text}\n#{extra_lines_text}".chomp
+              elsif missing_lines_text
+                missing_lines_text
+              elsif extra_lines_text
+                extra_lines_text
+              else
+                ""
+              end
+
+              if actual_contents == ""
+                errors << <<~CODEOWNERS_ERROR
+                  CODEOWNERS out of date. Run `bin/codeownership validate` to update the CODEOWNERS file
+                CODEOWNERS_ERROR
+              else
+                errors << <<~CODEOWNERS_ERROR
+                  CODEOWNERS out of date. Run `bin/codeownership validate` to update the CODEOWNERS file
+
+                  #{diff_text.chomp}
+                CODEOWNERS_ERROR
+              end
             end
           end
 
@@ -56,7 +98,7 @@ module CodeOwnership
         # https://help.github.com/articles/about-codeowners/
         sig { returns(T::Array[String]) }
         def codeowners_file_lines
-          github_team_map = Teams.all.each_with_object({}) do |team, map|
+          github_team_map = CodeTeams.all.each_with_object({}) do |team, map|
             team_github = TeamPlugins::Github.for(team).github
             next if team_github.do_not_add_to_codeowners_file
 

data/lib/code_ownership/private.rb

@@ -50,7 +50,7 @@ module CodeOwnership
       end
 
       if errors.any?
-        errors << 'See https://github.com/bigrails/code_ownership#README.md for more details'
+        errors << 'See https://github.com/rubyatscale/code_ownership#README.md for more details'
         raise InvalidCodeOwnershipConfigurationError.new(errors.join("\n")) # rubocop:disable Style/RaiseArgs
       end
     end
@@ -92,11 +92,11 @@ module CodeOwnership
       @tracked_files ||= Dir.glob(configuration.owned_globs)
     end
 
-    sig { params(team_name: String, location_of_reference: String).returns(Teams::Team) }
+    sig { params(team_name: String, location_of_reference: String).returns(CodeTeams::Team) }
     def self.find_team!(team_name, location_of_reference)
-      found_team = Teams.find(team_name)
+      found_team = CodeTeams.find(team_name)
       if found_team.nil?
-        raise StandardError, "Could not find team with name: `#{team_name}` in #{location_of_reference}. Make sure the team is one of `#{Teams.all.map(&:name).sort}`"
+        raise StandardError, "Could not find team with name: `#{team_name}` in #{location_of_reference}. Make sure the team is one of `#{CodeTeams.all.map(&:name).sort}`"
       else
         found_team
       end

data/lib/code_ownership.rb

@@ -3,7 +3,7 @@
 # typed: strict
 
 require 'set'
-require 'teams'
+require 'code_teams'
 require 'sorbet-runtime'
 require 'json'
 require 'parse_packwerk'
@@ -17,15 +17,15 @@ module CodeOwnership
 
   requires_ancestor { Kernel }
 
-  sig { params(file: String).returns(T.nilable(Teams::Team)) }
+  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(Teams::Team)]))
+    @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)
 
-    owner = T.let(nil, T.nilable(Teams::Team))
+    owner = T.let(nil, T.nilable(CodeTeams::Team))
 
     Private.mappers.each do |mapper|
       owner = mapper.map_file_to_owner(file)
@@ -61,7 +61,7 @@ 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[::Teams::Team]).returns(T.nilable(::Teams::Team)) }
+  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: [])
     return unless backtrace
 
@@ -93,9 +93,9 @@ module CodeOwnership
     nil
   end
 
-  sig { params(klass: T.nilable(T.any(Class, Module))).returns(T.nilable(::Teams::Team)) }
+  sig { params(klass: T.nilable(T.any(Class, Module))).returns(T.nilable(::CodeTeams::Team)) }
   def for_class(klass)
-    @memoized_values ||= T.let(@memoized_values, T.nilable(T::Hash[String, T.nilable(::Teams::Team)]))
+    @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)
@@ -110,7 +110,7 @@ module CodeOwnership
     end
   end
 
-  sig { params(package: ParsePackwerk::Package).returns(T.nilable(::Teams::Team)) }
+  sig { params(package: ParsePackwerk::Package).returns(T.nilable(::CodeTeams::Team)) }
   def for_package(package)
     Private::OwnershipMappers::PackageOwnership.new.owner_for_package(package)
   end

data/sorbet/rbi/gems/{bigrails-teams@0.1.0.rbi → code_teams@1.0.0.rbi}

@@ -1,78 +1,78 @@
 # typed: true
 
 # DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `bigrails-teams` gem.
-# Please instead update this file by running `bin/tapioca gem bigrails-teams`.
+# This is an autogenerated file for types exported from the `code_teams` gem.
+# Please instead update this file by running `bin/tapioca gem code_teams`.
 
-module Teams
+module CodeTeams
   class << self
-    sig { returns(T::Array[::Teams::Team]) }
+    sig { returns(T::Array[::CodeTeams::Team]) }
     def all; end
 
     sig { void }
     def bust_caches!; end
 
-    sig { params(name: ::String).returns(T.nilable(::Teams::Team)) }
+    sig { params(name: ::String).returns(T.nilable(::CodeTeams::Team)) }
     def find(name); end
 
-    sig { params(dir: ::String).returns(T::Array[::Teams::Team]) }
+    sig { params(dir: ::String).returns(T::Array[::CodeTeams::Team]) }
     def for_directory(dir); end
 
     sig { params(string: ::String).returns(::String) }
     def tag_value_for(string); end
 
-    sig { params(teams: T::Array[::Teams::Team]).returns(T::Array[::String]) }
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
     def validation_errors(teams); end
   end
 end
 
-class Teams::IncorrectPublicApiUsageError < ::StandardError; end
+class CodeTeams::IncorrectPublicApiUsageError < ::StandardError; end
 
-class Teams::Plugin
+class CodeTeams::Plugin
   abstract!
 
-  sig { params(team: ::Teams::Team).void }
+  sig { params(team: ::CodeTeams::Team).void }
   def initialize(team); end
 
   class << self
-    sig { returns(T::Array[T.class_of(Teams::Plugin)]) }
+    sig { returns(T::Array[T.class_of(CodeTeams::Plugin)]) }
     def all_plugins; end
 
-    sig { params(team: ::Teams::Team).returns(T.attached_class) }
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
     def for(team); end
 
     sig { params(base: T.untyped).void }
     def inherited(base); end
 
-    sig { params(team: ::Teams::Team, key: ::String).returns(::String) }
+    sig { params(team: ::CodeTeams::Team, key: ::String).returns(::String) }
     def missing_key_error_message(team, key); end
 
-    sig { params(teams: T::Array[::Teams::Team]).returns(T::Array[::String]) }
+    sig { params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
     def validation_errors(teams); end
 
     private
 
-    sig { params(team: ::Teams::Team).returns(T.attached_class) }
+    sig { params(team: ::CodeTeams::Team).returns(T.attached_class) }
     def register_team(team); end
 
-    sig { returns(T::Hash[T.nilable(::String), T::Hash[::Class, ::Teams::Plugin]]) }
+    sig { returns(T::Hash[T.nilable(::String), T::Hash[::Class, ::CodeTeams::Plugin]]) }
     def registry; end
   end
 end
 
-module Teams::Plugins; end
+module CodeTeams::Plugins; end
 
-class Teams::Plugins::Identity < ::Teams::Plugin
-  sig { returns(::Teams::Plugins::Identity::IdentityStruct) }
+class CodeTeams::Plugins::Identity < ::CodeTeams::Plugin
+  sig { returns(::CodeTeams::Plugins::Identity::IdentityStruct) }
   def identity; end
 
   class << self
-    sig { override.params(teams: T::Array[::Teams::Team]).returns(T::Array[::String]) }
+    sig { override.params(teams: T::Array[::CodeTeams::Team]).returns(T::Array[::String]) }
     def validation_errors(teams); end
   end
 end
 
-class Teams::Plugins::Identity::IdentityStruct < ::Struct
+class CodeTeams::Plugins::Identity::IdentityStruct < ::Struct
   def name; end
   def name=(_); end
 
@@ -84,7 +84,7 @@ class Teams::Plugins::Identity::IdentityStruct < ::Struct
   end
 end
 
-class Teams::Team
+class CodeTeams::Team
   sig { params(config_yml: T.nilable(::String), raw_hash: T::Hash[T.untyped, T.untyped]).void }
   def initialize(config_yml:, raw_hash:); end
 
@@ -109,12 +109,12 @@ class Teams::Team
   def to_tag; end
 
   class << self
-    sig { params(raw_hash: T::Hash[T.untyped, T.untyped]).returns(::Teams::Team) }
+    sig { params(raw_hash: T::Hash[T.untyped, T.untyped]).returns(::CodeTeams::Team) }
     def from_hash(raw_hash); end
 
-    sig { params(config_yml: ::String).returns(::Teams::Team) }
+    sig { params(config_yml: ::String).returns(::CodeTeams::Team) }
     def from_yml(config_yml); end
   end
 end
 
-Teams::UNKNOWN_TEAM_STRING = T.let(T.unsafe(nil), String)
+CodeTeams::UNKNOWN_TEAM_STRING = T.let(T.unsafe(nil), String)

data/sorbet/rbi/gems/{parse_packwerk@0.7.0.rbi → parse_packwerk@0.12.0.rbi}

@@ -6,12 +6,18 @@
 
 module ParsePackwerk
   class << self
-    sig { params(package_yml_pathnames: T.nilable(T::Array[::Pathname])).returns(T::Array[::ParsePackwerk::Package]) }
-    def all(package_yml_pathnames: T.unsafe(nil)); end
+    sig { returns(T::Array[::ParsePackwerk::Package]) }
+    def all; end
+
+    sig { void }
+    def bust_cache!; end
 
     sig { params(name: ::String).returns(T.nilable(::ParsePackwerk::Package)) }
     def find(name); end
 
+    sig { params(file_path: T.any(::Pathname, ::String)).returns(T.nilable(::ParsePackwerk::Package)) }
+    def package_from_path(file_path); end
+
     sig { params(package: ::ParsePackwerk::Package).void }
     def write_package_yml!(package); end
 
@@ -27,12 +33,24 @@ end
 
 class ParsePackwerk::Configuration < ::T::Struct
   const :exclude, T::Array[::String]
+  const :package_paths, T::Array[::String]
 
   class << self
+    sig { params(config_hash: T::Hash[T.untyped, T.untyped]).returns(T::Array[::String]) }
+    def excludes(config_hash); end
+
+    sig { returns(::ParsePackwerk::Configuration) }
+    def fetch; end
+
     def inherited(s); end
+
+    sig { params(config_hash: T::Hash[T.untyped, T.untyped]).returns(T::Array[::String]) }
+    def package_paths(config_hash); end
   end
 end
 
+ParsePackwerk::DEFAULT_EXCLUDE_GLOBS = T.let(T.unsafe(nil), Array)
+ParsePackwerk::DEFAULT_PACKAGE_PATHS = T.let(T.unsafe(nil), Array)
 ParsePackwerk::DEPENDENCIES = T.let(T.unsafe(nil), String)
 ParsePackwerk::DEPRECATED_REFERENCES_YML_NAME = T.let(T.unsafe(nil), String)
 
@@ -91,6 +109,23 @@ class ParsePackwerk::Package < ::T::Struct
   end
 end
 
+class ParsePackwerk::PackageSet
+  class << self
+    sig do
+      params(
+        package_pathspec: T::Array[::String],
+        exclude_pathspec: T::Array[::String]
+      ).returns(T::Array[::ParsePackwerk::Package])
+    end
+    def from(package_pathspec:, exclude_pathspec:); end
+
+    private
+
+    sig { params(globs: T::Array[::String], path: ::Pathname).returns(T::Boolean) }
+    def exclude_path?(globs, path); end
+  end
+end
+
 ParsePackwerk::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
 
 class ParsePackwerk::Violation < ::T::Struct

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: code_ownership
 version: !ruby/object:Gem::Version
-  version: 1.26.0
+  version: 1.28.2
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-06-01 00:00:00.000000000 Z
+date: 2022-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bigrails-teams
+  name: code_teams
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: parse_packwerk
   requirement: !ruby/object:Gem::Requirement
@@ -149,17 +149,17 @@ files:
 - lib/code_ownership/private/validations/github_codeowners_up_to_date.rb
 - lib/code_ownership/private/validations/interface.rb
 - sorbet/config
-- sorbet/rbi/gems/bigrails-teams@0.1.0.rbi
-- sorbet/rbi/gems/parse_packwerk@0.7.0.rbi
+- sorbet/rbi/gems/code_teams@1.0.0.rbi
+- sorbet/rbi/gems/parse_packwerk@0.12.0.rbi
 - sorbet/rbi/manual.rbi
 - sorbet/rbi/todo.rbi
-homepage: https://github.com/bigrails/code_ownership
+homepage: https://github.com/rubyatscale/code_ownership
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/bigrails/code_ownership
-  source_code_uri: https://github.com/bigrails/code_ownership
-  changelog_uri: https://github.com/bigrails/code_ownership/releases
+  homepage_uri: https://github.com/rubyatscale/code_ownership
+  source_code_uri: https://github.com/rubyatscale/code_ownership
+  changelog_uri: https://github.com/rubyatscale/code_ownership/releases
   allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []