modularization_statistics 1.33.0 → 1.36.0

data/lib/modularization_statistics/private/metrics/packages.rb

@@ -0,0 +1,109 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class Packages
+        extend T::Sig
+
+        sig do
+          params(
+            packages: T::Array[ParsePackwerk::Package],
+            app_name: String
+          ).returns(T::Array[GaugeMetric])
+        end
+        def self.get_package_metrics(packages, app_name)
+          all_metrics = []
+          app_level_tag = Tag.for('app', app_name)
+          package_tags = T.let([app_level_tag], T::Array[Tag])
+          protected_packages = packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
+
+          all_metrics << GaugeMetric.for('all_packages.count', packages.count, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.dependencies.count', packages.sum { |package| package.dependencies.count }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.dependency_violations.count', protected_packages.sum { |package| Metrics.file_count(package.violations.select(&:dependency?)) }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.privacy_violations.count', protected_packages.sum { |package| Metrics.file_count(package.violations.select(&:privacy?)) }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.enforcing_dependencies.count', packages.count(&:enforces_dependencies?), package_tags)
+          all_metrics << GaugeMetric.for('all_packages.enforcing_privacy.count', packages.count(&:enforces_privacy?), package_tags)
+
+          all_metrics << GaugeMetric.for('all_packages.notify_on_package_yml_changes.count', packages.count { |p| p.metadata['notify_on_package_yml_changes'] }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.notify_on_new_violations.count', packages.count { |p| p.metadata['notify_on_new_violations'] }, package_tags)
+
+          all_metrics << GaugeMetric.for('all_packages.with_violations.count', protected_packages.count { |package| package.violations.any? }, package_tags)
+          all_metrics += Metrics::PublicUsage.get_public_usage_metrics('all_packages', packages, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.has_readme.count', packages.count { |package| Metrics.has_readme?(package) }, package_tags)
+
+          all_metrics += Metrics::ProtectionUsage.get_protections_metrics('all_packages', protected_packages, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.package_based_file_ownership.count', packages.count { |package| !package.metadata['owner'].nil? }, package_tags)
+
+          inbound_violations_by_package = protected_packages.flat_map(&:violations).group_by(&:to_package_name)
+
+          protected_packages.each do |protected_package|
+            package = protected_package.original_package
+            package_tags = Metrics.tags_for_package(package, app_name)
+
+            #
+            # VIOLATIONS (implicit dependencies)
+            #
+            outbound_violations = protected_package.violations
+            inbound_violations = inbound_violations_by_package[package.name] || []
+            all_dependency_violations = (outbound_violations + inbound_violations).select(&:dependency?)
+            all_privacy_violations = (outbound_violations + inbound_violations).select(&:privacy?)
+
+            all_metrics << GaugeMetric.for('by_package.dependency_violations.count', Metrics.file_count(all_dependency_violations), package_tags)
+            all_metrics << GaugeMetric.for('by_package.privacy_violations.count', Metrics.file_count(all_privacy_violations), package_tags)
+
+            all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.count', Metrics.file_count(outbound_violations.select(&:dependency?)), package_tags)
+            all_metrics << GaugeMetric.for('by_package.inbound_dependency_violations.count', Metrics.file_count(inbound_violations.select(&:dependency?)), package_tags)
+
+            all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.count', Metrics.file_count(outbound_violations.select(&:privacy?)), package_tags)
+            all_metrics << GaugeMetric.for('by_package.inbound_privacy_violations.count', Metrics.file_count(inbound_violations.select(&:privacy?)), package_tags)
+
+            all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_package', [package], package_tags)
+
+            protected_package.violations.group_by(&:to_package_name).each do |to_package_name, violations|
+              to_package = ParsePackwerk.find(to_package_name)
+              if to_package.nil?
+                raise StandardError, "Could not find matching package #{to_package_name}"
+              end
+
+              tags = package_tags + [Tag.for('to_package', Metrics.humanized_package_name(to_package_name))] + Metrics.tags_for_to_team(CodeOwnership.for_package(to_package)&.name)
+              all_metrics << GaugeMetric.for('by_package.outbound_dependency_violations.per_package.count', Metrics.file_count(violations.select(&:dependency?)), tags)
+              all_metrics << GaugeMetric.for('by_package.outbound_privacy_violations.per_package.count', Metrics.file_count(violations.select(&:privacy?)), tags)
+            end
+          end
+
+          inbound_explicit_dependency_by_package = {}
+          packages.each do |package|
+            package.dependencies.each do |explicit_dependency|
+              inbound_explicit_dependency_by_package[explicit_dependency] ||= []
+              inbound_explicit_dependency_by_package[explicit_dependency] << package.name
+            end
+          end
+
+          packages.each do |package| # rubocop:disable Style/CombinableLoops
+            package_tags = Metrics.tags_for_package(package, app_name)
+
+            #
+            # EXPLICIT DEPENDENCIES
+            #
+            package.dependencies.each do |explicit_dependency|
+              to_package = ParsePackwerk.find(explicit_dependency)
+              if to_package.nil?
+                raise StandardError, "Could not find matching package #{explicit_dependency}"
+              end
+
+              tags = package_tags + [Tag.for('to_package', Metrics.humanized_package_name(explicit_dependency))] + Metrics.tags_for_to_team(CodeOwnership.for_package(to_package)&.name)
+              all_metrics << GaugeMetric.for('by_package.outbound_explicit_dependencies.per_package.count', 1, tags)
+            end
+
+            all_metrics << GaugeMetric.for('by_package.outbound_explicit_dependencies.count', package.dependencies.count, package_tags)
+            all_metrics << GaugeMetric.for('by_package.inbound_explicit_dependencies.count', inbound_explicit_dependency_by_package[package.name]&.count || 0, package_tags)
+          end
+
+          all_metrics
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics/packages_by_team.rb

@@ -0,0 +1,73 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class PackagesByTeam
+        extend T::Sig
+
+        sig do
+          params(
+            all_packages: T::Array[ParsePackwerk::Package],
+            app_name: String
+          ).returns(T::Array[GaugeMetric])
+        end
+        def self.get_package_metrics_by_team(all_packages, app_name)
+          all_metrics = T.let([], T::Array[GaugeMetric])
+          app_level_tag = Tag.for('app', app_name)
+          all_protected_packages = all_packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
+          all_protected_packages.group_by { |protected_package| CodeOwnership.for_package(protected_package.original_package)&.name }.each do |team_name, protected_packages_by_team|
+            # We look at `all_packages` because we care about ALL inbound violations across all teams
+            inbound_violations_by_package = all_protected_packages.flat_map(&:violations).group_by(&:to_package_name)
+
+            team_tags = Metrics.tags_for_team(team_name) + [app_level_tag]
+            all_metrics << GaugeMetric.for('by_team.all_packages.count', protected_packages_by_team.count, team_tags)
+            all_metrics += Metrics::ProtectionUsage.get_protections_metrics('by_team', protected_packages_by_team, team_tags)
+            all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_team', protected_packages_by_team.map(&:original_package), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.notify_on_package_yml_changes.count', protected_packages_by_team.count { |p| p.metadata['notify_on_package_yml_changes'] }, team_tags)
+            all_metrics << GaugeMetric.for('by_team.notify_on_new_violations.count', protected_packages_by_team.count { |p| p.metadata['notify_on_new_violations'] }, team_tags)
+
+            #
+            # VIOLATIONS (implicit dependencies)
+            #
+            outbound_violations = protected_packages_by_team.flat_map(&:violations)
+            # Here we only look at packages_by_team because we only care about inbound violations onto packages for this team
+            inbound_violations = protected_packages_by_team.flat_map { |package| inbound_violations_by_package[package.name] || [] }
+            all_dependency_violations = (outbound_violations + inbound_violations).select(&:dependency?)
+            all_privacy_violations = (outbound_violations + inbound_violations).select(&:privacy?)
+
+            all_metrics << GaugeMetric.for('by_team.dependency_violations.count', Metrics.file_count(all_dependency_violations), team_tags)
+            all_metrics << GaugeMetric.for('by_team.privacy_violations.count', Metrics.file_count(all_privacy_violations), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.count', Metrics.file_count(outbound_violations.select(&:dependency?)), team_tags)
+            all_metrics << GaugeMetric.for('by_team.inbound_dependency_violations.count', Metrics.file_count(inbound_violations.select(&:dependency?)), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.count', Metrics.file_count(outbound_violations.select(&:privacy?)), team_tags)
+            all_metrics << GaugeMetric.for('by_team.inbound_privacy_violations.count', Metrics.file_count(inbound_violations.select(&:privacy?)), team_tags)
+
+            all_metrics << GaugeMetric.for('by_team.has_readme.count', protected_packages_by_team.count { |protected_package| Metrics.has_readme?(protected_package.original_package) }, team_tags)
+
+            grouped_outbound_violations = outbound_violations.group_by do |violation|
+              to_package = ParsePackwerk.find(violation.to_package_name)
+              if to_package.nil?
+                raise StandardError, "Could not find matching package #{violation.to_package_name}"
+              end
+
+              CodeOwnership.for_package(to_package)&.name
+            end
+
+            grouped_outbound_violations.each do |to_team_name, violations|
+              tags = team_tags + Metrics.tags_for_to_team(to_team_name)
+              all_metrics << GaugeMetric.for('by_team.outbound_dependency_violations.per_team.count', Metrics.file_count(violations.select(&:dependency?)), tags)
+              all_metrics << GaugeMetric.for('by_team.outbound_privacy_violations.per_team.count', Metrics.file_count(violations.select(&:privacy?)), tags)
+            end
+          end
+
+          all_metrics
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics/protection_usage.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class ProtectionUsage
+        extend T::Sig
+
+        sig { params(prefix: String, protected_packages: T::Array[PackageProtections::ProtectedPackage], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_protections_metrics(prefix, protected_packages, package_tags)
+          PackageProtections.all.flat_map do |protection|
+            PackageProtections::ViolationBehavior.each_value.map do |violation_behavior|
+              # https://github.com/Gusto/package_protections/pull/42 changed the public API of these violation behaviors.
+              # To preserve our ability to understand historical trends, we map to the old values.
+              # This allows our dashboards to continue to operate as expected.
+              # Note if we ever open source mod stats, we should probably inject this behavior so that new clients can see the new keys in their metrics.
+              violation_behavior_map = {
+                PackageProtections::ViolationBehavior::FailOnAny => 'fail_the_build_on_any_instances',
+                PackageProtections::ViolationBehavior::FailNever => 'no',
+                PackageProtections::ViolationBehavior::FailOnNew => 'fail_the_build_if_new_instances_appear',
+              }
+              violation_behavior_name = violation_behavior_map[violation_behavior]
+              metric_name = "#{prefix}.#{protection.identifier}.#{violation_behavior_name}.count"
+              count_of_packages = protected_packages.count { |p| p.violation_behavior_for(protection.identifier) == violation_behavior }
+              GaugeMetric.for(metric_name, count_of_packages, package_tags)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics/public_usage.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class PublicUsage
+        extend T::Sig
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_public_usage_metrics(prefix, packages, package_tags)
+          packages_except_for_root = packages.reject { |package| package.name == ParsePackwerk::ROOT_PACKAGE_NAME }
+          all_files = packages_except_for_root.flat_map do |package|
+            package.directory.glob('**/**.rb')
+          end
+
+          all_public_files = T.let([], T::Array[Pathname])
+          is_using_public_directory = 0
+          packages_except_for_root.each do |package|
+            public_files = package.directory.glob('app/public/**/**.rb')
+            all_public_files += public_files
+            is_using_public_directory += 1 if public_files.any?
+          end
+
+          # In Datadog, we can divide public files by all files to get the ratio.
+          # This is not a metric that we are targeting -- its for observability and reflection only.
+          [
+            GaugeMetric.for("#{prefix}.all_files.count", all_files.count, package_tags),
+            GaugeMetric.for("#{prefix}.public_files.count", all_public_files.count, package_tags),
+            GaugeMetric.for("#{prefix}.using_public_directory.count", is_using_public_directory, package_tags),
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/metrics.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      extend T::Sig
+      UNKNOWN_OWNER = T.let('Unknown', String)
+
+      sig { params(team_name: T.nilable(String)).returns(T::Array[Tag]) }
+      def self.tags_for_team(team_name)
+        [Tag.for('team', team_name || UNKNOWN_OWNER)]
+      end
+
+      sig { params(package: ParsePackwerk::Package, app_name: String).returns(T::Array[Tag]) }
+      def self.tags_for_package(package, app_name)
+        [
+          Tag.new(key: 'package', value: humanized_package_name(package.name)),
+          Tag.new(key: 'app', value: app_name),
+          *Metrics.tags_for_team(CodeOwnership.for_package(package)&.name),
+        ]
+      end
+
+      sig { params(team_name: T.nilable(String)).returns(T::Array[Tag]) }
+      def self.tags_for_to_team(team_name)
+        [Tag.for('to_team', team_name || Metrics::UNKNOWN_OWNER)]
+      end
+
+      sig { params(name: String).returns(String) }
+      def self.humanized_package_name(name)
+        if name == ParsePackwerk::ROOT_PACKAGE_NAME
+          'root'
+        else
+          name
+        end
+      end
+
+      sig { params(violations: T::Array[ParsePackwerk::Violation]).returns(Integer) }
+      def self.file_count(violations)
+        violations.sum { |v| v.files.count }
+      end
+
+      sig { params(package: ParsePackwerk::Package).returns(T::Boolean) }
+      def self.has_readme?(package)
+        package.directory.join('README.md').exist?
+      end
+    end
+  end
+end

data/lib/modularization_statistics/private/source_code_file.rb

@@ -7,7 +7,7 @@ module ModularizationStatistics
 
       const :is_componentized_file, T::Boolean
       const :is_packaged_file, T::Boolean
-      const :team_owner, T.nilable(Teams::Team)
+      const :team_owner, T.nilable(CodeTeams::Team)
       const :pathname, Pathname
 
       sig { returns(T::Boolean) }

data/lib/modularization_statistics.rb

@@ -4,7 +4,7 @@ require 'sorbet-runtime'
 require 'json'
 require 'yaml'
 require 'benchmark'
-require 'teams'
+require 'code_teams'
 require 'code_ownership'
 require 'pathname'
 require 'modularization_statistics/private/source_code_file'

data/sorbet/rbi/gems/{code_ownership@1.23.0.rbi → code_ownership@1.28.0.rbi}

@@ -12,18 +12,18 @@ module CodeOwnership
   sig do
     params(
       backtrace: T.nilable(T::Array[::String]),
-      excluded_teams: T::Array[::Teams::Team]
-    ).returns(T.nilable(::Teams::Team))
+      excluded_teams: T::Array[::CodeTeams::Team]
+    ).returns(T.nilable(::CodeTeams::Team))
   end
   def for_backtrace(backtrace, excluded_teams: T.unsafe(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); end
 
-  sig { params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def for_file(file); 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); end
 
   sig { params(files: T::Array[::String], autocorrect: T::Boolean, stage_changes: T::Boolean).void }
@@ -40,6 +40,7 @@ end
 
 class CodeOwnership::Cli
   class << self
+    def for_file(argv); end
     def run!(argv); end
 
     private
@@ -64,7 +65,7 @@ module CodeOwnership::Private
     sig { params(files: T::Array[::String]).returns(T::Hash[::String, T::Array[::String]]) }
     def files_by_mapper(files); 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 find_team!(team_name, location_of_reference); end
 
     sig { returns(T::Array[::CodeOwnership::Private::OwnershipMappers::Interface]) }
@@ -107,19 +108,19 @@ class CodeOwnership::Private::OwnershipMappers::FileAnnotations
   sig { override.void }
   def bust_caches!; end
 
-  sig { override.returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def codeowners_lines_to_owners; end
 
   sig { override.returns(::String) }
   def description; 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); end
 
-  sig { override.params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def map_file_to_owner(file); end
 
-  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def map_files_to_owners(files); end
 
   sig { params(filename: ::String).void }
@@ -134,16 +135,16 @@ module CodeOwnership::Private::OwnershipMappers::Interface
   sig { abstract.void }
   def bust_caches!; end
 
-  sig { abstract.returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { abstract.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def codeowners_lines_to_owners; end
 
   sig { abstract.returns(::String) }
   def description; end
 
-  sig { abstract.params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { abstract.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def map_file_to_owner(file); end
 
-  sig { abstract.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { abstract.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def map_files_to_owners(files); end
 end
 
@@ -153,19 +154,19 @@ class CodeOwnership::Private::OwnershipMappers::JsPackageOwnership
   sig { override.void }
   def bust_caches!; end
 
-  sig { override.returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def codeowners_lines_to_owners; end
 
   sig { override.returns(::String) }
   def description; end
 
-  sig { override.params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def map_file_to_owner(file); end
 
-  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def map_files_to_owners(files); end
 
-  sig { params(package: ::CodeOwnership::Private::ParseJsPackages::Package).returns(T.nilable(::Teams::Team)) }
+  sig { params(package: ::CodeOwnership::Private::ParseJsPackages::Package).returns(T.nilable(::CodeTeams::Team)) }
   def owner_for_package(package); end
 
   private
@@ -180,19 +181,19 @@ class CodeOwnership::Private::OwnershipMappers::PackageOwnership
   sig { override.void }
   def bust_caches!; end
 
-  sig { override.returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def codeowners_lines_to_owners; end
 
   sig { override.returns(::String) }
   def description; end
 
-  sig { override.params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def map_file_to_owner(file); end
 
-  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def map_files_to_owners(files); 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); end
 
   private
@@ -207,16 +208,16 @@ class CodeOwnership::Private::OwnershipMappers::TeamGlobs
   sig { override.void }
   def bust_caches!; end
 
-  sig { override.returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def codeowners_lines_to_owners; end
 
   sig { override.returns(::String) }
   def description; end
 
-  sig { override.params(file: ::String).returns(T.nilable(::Teams::Team)) }
+  sig { override.params(file: ::String).returns(T.nilable(::CodeTeams::Team)) }
   def map_file_to_owner(file); end
 
-  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::Teams::Team)]) }
+  sig { override.params(files: T::Array[::String]).returns(T::Hash[::String, T.nilable(::CodeTeams::Team)]) }
   def map_files_to_owners(files); end
 end
 
@@ -248,7 +249,7 @@ end
 CodeOwnership::Private::ParseJsPackages::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
 module CodeOwnership::Private::TeamPlugins; end
 
-class CodeOwnership::Private::TeamPlugins::Github < ::Teams::Plugin
+class CodeOwnership::Private::TeamPlugins::Github < ::CodeTeams::Plugin
   sig { returns(::CodeOwnership::Private::TeamPlugins::Github::GithubStruct) }
   def github; end
 end
@@ -267,7 +268,7 @@ class CodeOwnership::Private::TeamPlugins::Github::GithubStruct < ::Struct
   end
 end
 
-class CodeOwnership::Private::TeamPlugins::Ownership < ::Teams::Plugin
+class CodeOwnership::Private::TeamPlugins::Ownership < ::CodeTeams::Plugin
   sig { returns(T::Array[::String]) }
   def owned_globs; end
 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)