modularization_statistics 1.41.0 → 1.43.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98507b7d02a58d6a68c9ba40d9962abf6369dc68959d7a95f6d3a49384f902f4
-  data.tar.gz: 5d12d05d262833e8b1534a6b38f8162b2a3c4bd57d584ceb260a5c8d6c99ab0a
+  metadata.gz: f62a7a832093f586bea43e63af693a848f52cf0e4528348746424d4a80c10d12
+  data.tar.gz: a7d15eff1dc8014fd5552372081d6a171dff2625dade956b6ef0554e45631c3f
 SHA512:
-  metadata.gz: 41ddf6056104fcc66a39f44bf50e4783cd69fe70aa88414bd5459c365bd0285439d3bfe8651b4ab3059f849759b8e37afe5502fdf907654798640a6c9cade2ff
-  data.tar.gz: f72b2b1c78f6bddbeac30bfd074b3a8b2bcc0b18e20ad9fc0b311e32ee4514aabc95683d12642b0287cbea41457e46f7468fa849f6b198ff06703f69f768534a
+  metadata.gz: 2b510bef418709597c3c215d24752de7db71f411765517c350cfc4e8ebf5e396ecb7399ab340defbdc8bb6538e38cdb713f2d209407c5ced0ed4ff0a17f9b04a
+  data.tar.gz: 3dc87181542fcb8bcb37561d9aa12df9ebe152f397da7c5f01c3b5b579c048102e9640929d1d6e6d3d806d6bbf5386524b411d2679324bf483e335d8b8065730

data/README.md

@@ -2,6 +2,11 @@
 
 This gem is used to report opinionated statistics about modularization to DataDog and other observability systems.
 
+# Configuring Ownership
+The gem reports metrics per-team, where each team is configured based on metadata included in Packwerk package.yml files.
+
+Define your teams as described in the [Code Team - Package Based Ownership](https://github.com/rubyatscale/code_ownership#package-based-ownership) documentation.
+
 # Usage
 The main method to this gem is `ModularizationStatistics#report_to_datadog!`. Refer to the Sorbet signature for this method for the exact types to be passed in.
 
@@ -19,8 +24,8 @@ ModularizationStatistics.report_to_datadog!(
   # Example: Time.now
   #
   report_time: report_time
-  # 
-  # This is used to determine what files to look at for building statistics about what types of files are packaged, componentized, or unpackaged. 
+  #
+  # This is used to determine what files to look at for building statistics about what types of files are packaged, componentized, or unpackaged.
   # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
   #
   # Example: source_code_pathnames = Pathname.glob('./**/**.rb')
@@ -33,7 +38,7 @@ ModularizationStatistics.report_to_datadog!(
   # Example: [Pathname.new("./gems")]
   #
   componentized_source_code_locations: componentized_source_code_locations,
-  # 
+  #
   # A file is determined to be packaged if it exists in any of these directories.
   # This is an array of `Pathname`. `Pathname` can be relative or absolute paths.
   #

data/lib/modularization_statistics/private/datadog_reporter.rb

@@ -5,8 +5,8 @@ require 'dogapi'
 require 'modularization_statistics/private/metrics'
 require 'modularization_statistics/private/metrics/files'
 require 'modularization_statistics/private/metrics/public_usage'
-require 'modularization_statistics/private/metrics/protection_usage'
-require 'modularization_statistics/private/metrics/rubocop_protections_exclusions'
+require 'modularization_statistics/private/metrics/packwerk_checker_usage'
+require 'modularization_statistics/private/metrics/rubocop_usage'
 require 'modularization_statistics/private/metrics/packages'
 require 'modularization_statistics/private/metrics/packages_by_team'
 require 'modularization_statistics/private/metrics/nested_packs'

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

@@ -32,8 +32,8 @@ module ModularizationStatistics
           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', packages, package_tags)
-          all_metrics += Metrics::RubocopProtectionsExclusions.get_rubocop_exclusions('all_packages', packages, package_tags)
+          all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics('all_packages', packages, package_tags)
+          all_metrics += Metrics::RubocopUsage.get_metrics('all_packages', 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 = packages.flat_map(&:violations).group_by(&:to_package_name)

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

@@ -23,7 +23,7 @@ module ModularizationStatistics
 
             team_tags = Metrics.tags_for_team(team_name) + [app_level_tag]
             all_metrics << GaugeMetric.for('by_team.all_packages.count', packages_by_team.count, team_tags)
-            all_metrics += Metrics::ProtectionUsage.get_protections_metrics('by_team', packages_by_team, team_tags)
+            all_metrics += Metrics::PackwerkCheckerUsage.get_checker_metrics('by_team', packages_by_team, team_tags)
             all_metrics += Metrics::PublicUsage.get_public_usage_metrics('by_team', packages_by_team, team_tags)
 
             all_metrics << GaugeMetric.for('by_team.notify_on_package_yml_changes.count', packages_by_team.count { |p| p.metadata['notify_on_package_yml_changes'] }, team_tags)

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

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'rubocop-packs'
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class PackwerkCheckerUsage
+        extend T::Sig
+        
+        # Later, we might find a way we can get this directly from `packwerk`
+        class PackwerkChecker < T::Struct
+          const :setting, String
+          const :strict_mode, String
+          # Later, we might convert to legacy metric names later so new clients get more sensible metric names
+          # That is, we might want to see metrics that are more closely connected to the new API.
+          # e.g. instead of `all_packages.prevent_this_package_from_violating_its_stated_dependencies.fail_on_any.count`, we'd see `all_packages.checkers.enforce_dependencies.strict.count`
+          # e.g. instead of `all_packages.prevent_this_package_from_creating_other_namespaces.fail_on_new.count`, `all_packages.cops.packs_namespaceconvention.true.count`
+          const :legacy_metric_name, String
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_checker_metrics(prefix, packages, package_tags)
+          metrics = T.let([], T::Array[GaugeMetric])
+
+          checkers = [
+            PackwerkChecker.new(setting: 'enforce_dependencies', strict_mode: 'enforce_dependencies_strictly', legacy_metric_name: 'prevent_this_package_from_violating_its_stated_dependencies'),
+            PackwerkChecker.new(setting: 'enforce_privacy', strict_mode: 'enforce_privacy_strictly', legacy_metric_name: 'prevent_other_packages_from_using_this_packages_internals')
+          ]
+
+          checkers.each do |checker|
+            ['no', 'fail_the_build_if_new_instances_appear', 'fail_the_build_on_any_instances'].each do |violation_behavior|
+              count_of_packages = ParsePackwerk.all.count do |package|
+                strict_mode = package.metadata[checker.strict_mode]
+                enabled = YAML.load_file(package.yml)[checker.setting]
+                case violation_behavior
+                when 'fail_the_build_on_any_instances'
+                  !!strict_mode
+                when 'no'
+                  !enabled
+                when 'fail_the_build_if_new_instances_appear'
+                  enabled && !strict_mode
+                end
+              end
+
+              metric_name = "#{prefix}.#{checker.legacy_metric_name}.#{violation_behavior}.count"
+              metrics << GaugeMetric.for(metric_name, count_of_packages, package_tags)
+            end
+          end
+
+          metrics
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# typed: strict
+# frozen_string_literal: true
+
+module ModularizationStatistics
+  module Private
+    module Metrics
+      class RubocopUsage
+        extend T::Sig
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_metrics(prefix, packages, package_tags)
+          [
+            *get_rubocop_exclusions(prefix, packages, package_tags),
+            *get_rubocop_usage_metrics(prefix, packages, package_tags)
+          ]
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_rubocop_usage_metrics(prefix, packages, package_tags)
+          # Rubocops
+          metrics = T.let([], T::Array[GaugeMetric])
+          
+          rubocop_legacy_metric_map.each do |cop_name, legacy_name|
+            ['no', 'fail_the_build_if_new_instances_appear', 'fail_the_build_on_any_instances'].each do |violation_behavior|
+              count_of_packages = ParsePackwerk.all.count do |package|
+                # We will likely want a rubocop-packs API for this, to be able to ask if a cop is enabled for a pack.
+                # It's possible we will want to allow these to be enabled at the top-level `.rubocop.yml`,
+                # in which case we wouldn't get the right metrics with this approach. However, we can also accept
+                # that as a current limitation.
+                rubocop_yml_file = package.directory.join(RuboCop::Packs::PACK_LEVEL_RUBOCOP_YML)
+                next false if !rubocop_yml_file.exist?
+                rubocop_yml = YAML.load_file(rubocop_yml_file)
+                cop_config = rubocop_yml[cop_name]
+
+                strict_mode = cop_config && cop_config['FailureMode'] == 'strict'
+                enabled = cop_config && cop_config['Enabled']
+                case violation_behavior
+                when 'fail_the_build_on_any_instances'
+                  !!strict_mode
+                when 'no'
+                  !enabled
+                when 'fail_the_build_if_new_instances_appear'
+                  enabled && !strict_mode
+                end
+              end
+
+              metric_name = "#{prefix}.#{legacy_name}.#{violation_behavior}.count"
+              metrics << GaugeMetric.for(metric_name, count_of_packages, package_tags)
+            end
+          end
+
+          metrics
+        end
+
+        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
+        def self.get_rubocop_exclusions(prefix, packages, package_tags)
+          rubocop_legacy_metric_map.flat_map do |cop_name, legacy_name|
+            metric_name = "#{prefix}.#{legacy_name}.rubocop_exclusions.count"
+            all_exclusions_count = ParsePackwerk.all.sum { |package| exclude_count_for_package_and_protection(package, cop_name)}
+            GaugeMetric.for(metric_name, all_exclusions_count, package_tags)
+          end
+        end
+
+        # TODO: `rubocop-packs` may want to expose API for this
+        sig { params(package: ParsePackwerk::Package, cop_name: String).returns(Integer) }
+        def self.exclude_count_for_package_and_protection(package, cop_name)
+          if package.name == ParsePackwerk::ROOT_PACKAGE_NAME
+            rubocop_todo = package.directory.join('.rubocop_todo.yml')
+          else
+            rubocop_todo = package.directory.join(RuboCop::Packs::PACK_LEVEL_RUBOCOP_TODO_YML)
+          end
+
+          if rubocop_todo.exist?
+            loaded_rubocop_todo = YAML.load_file(rubocop_todo)
+            cop_config = loaded_rubocop_todo.fetch(cop_name, {})
+            cop_config.fetch('Exclude', []).count
+          else
+            0
+          end
+        end
+
+        sig { returns(T::Hash[String, String])}
+        def self.rubocop_legacy_metric_map
+          {
+            'Packs/ClassMethodsAsPublicApis' => 'prevent_this_package_from_exposing_an_untyped_api',
+            'Packs/RootNamespaceIsPackName' => 'prevent_this_package_from_creating_other_namespaces',
+            'Packs/TypedPublicApis' => 'prevent_this_package_from_exposing_an_untyped_api',
+            'Packs/DocumentedPublicApis' => 'prevent_this_package_from_exposing_undocumented_public_apis',
+          }
+        end
+      end
+    end
+  end
+end

data/lib/modularization_statistics.rb

@@ -10,7 +10,6 @@ require 'pathname'
 require 'modularization_statistics/private/source_code_file'
 require 'modularization_statistics/private/datadog_reporter'
 require 'parse_packwerk'
-require 'package_protections'
 require 'modularization_statistics/tag'
 require 'modularization_statistics/tags'
 require 'modularization_statistics/gauge_metric'

data/sorbet/rbi/gems/rubocop-packs@0.0.20.rbi

@@ -0,0 +1,141 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-packs` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop-packs`.
+
+module RuboCop; end
+module RuboCop::Cop; end
+module RuboCop::Cop::Packs; end
+
+class RuboCop::Cop::Packs::RootNamespaceIsPackName::DesiredZeitwerkApi
+  sig do
+    params(
+      relative_filename: ::String,
+      package_for_path: ::ParsePackwerk::Package
+    ).returns(T.nilable(::RuboCop::Cop::Packs::RootNamespaceIsPackName::DesiredZeitwerkApi::NamespaceContext))
+  end
+  def for_file(relative_filename, package_for_path); end
+
+  sig { params(pack: ::ParsePackwerk::Package).returns(::String) }
+  def get_pack_based_namespace(pack); end
+
+  private
+
+  sig { params(remaining_file_path: ::String, package_name: ::String).returns(::String) }
+  def get_actual_namespace(remaining_file_path, package_name); end
+
+  sig { params(pack: ::ParsePackwerk::Package).returns(::String) }
+  def get_package_last_name(pack); end
+
+  sig { returns(::Pathname) }
+  def root_pathname; end
+end
+
+class RuboCop::Cop::Packs::RootNamespaceIsPackName::DesiredZeitwerkApi::NamespaceContext < ::T::Struct
+  const :current_fully_qualified_constant, ::String
+  const :current_namespace, ::String
+  const :expected_filepath, ::String
+  const :expected_namespace, ::String
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+module RuboCop::Cop::PackwerkLite; end
+class RuboCop::Cop::PackwerkLite::ConstantResolver; end
+
+module RuboCop::Packs
+  class << self
+    sig { params(packs: T::Array[::ParsePackwerk::Package]).void }
+    def auto_generate_rubocop_todo(packs:); end
+
+    sig { void }
+    def bust_cache!; end
+
+    sig { returns(::RuboCop::Packs::Private::Configuration) }
+    def config; end
+
+    sig { params(blk: T.proc.params(arg0: ::RuboCop::Packs::Private::Configuration).void).void }
+    def configure(&blk); end
+
+    sig { params(rule: ::String).returns(T::Set[::String]) }
+    def exclude_for_rule(rule); end
+
+    sig { params(root_pathname: ::String).returns(::String) }
+    def pack_based_rubocop_config(root_pathname: T.unsafe(nil)); end
+
+    sig { params(packs: T::Array[::ParsePackwerk::Package]).void }
+    def set_default_rubocop_yml(packs:); end
+
+    sig { returns(T::Array[::String]) }
+    def validate; end
+  end
+end
+
+RuboCop::Packs::CONFIG = T.let(T.unsafe(nil), Hash)
+RuboCop::Packs::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
+class RuboCop::Packs::Error < ::StandardError; end
+
+module RuboCop::Packs::Inject
+  class << self
+    sig { void }
+    def defaults!; end
+  end
+end
+
+RuboCop::Packs::PACK_LEVEL_RUBOCOP_TODO_YML = T.let(T.unsafe(nil), String)
+RuboCop::Packs::PACK_LEVEL_RUBOCOP_YML = T.let(T.unsafe(nil), String)
+RuboCop::Packs::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
+
+module RuboCop::Packs::Private
+  class << self
+    sig { void }
+    def bust_cache!; end
+
+    sig { params(rule: ::String).returns(T::Set[::String]) }
+    def exclude_for_rule(rule); end
+
+    sig { void }
+    def load_client_configuration; end
+
+    sig { returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+    def rubocop_todo_ymls; end
+
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_failure_mode_strict(package); end
+
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_rubocop_todo_yml(package); end
+
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_rubocop_yml(package); end
+  end
+end
+
+class RuboCop::Packs::Private::Configuration
+  sig { void }
+  def initialize; end
+
+  sig { void }
+  def bust_cache!; end
+
+  sig { returns(T::Array[::String]) }
+  def globally_permitted_namespaces; end
+
+  def globally_permitted_namespaces=(_arg0); end
+
+  sig { returns(T::Array[::String]) }
+  def permitted_pack_level_cops; end
+
+  def permitted_pack_level_cops=(_arg0); end
+
+  sig { returns(T::Array[::String]) }
+  def required_pack_level_cops; end
+
+  def required_pack_level_cops=(_arg0); end
+end
+
+module RuboCop::PackwerkLite; end
+class RuboCop::PackwerkLite::Error < ::StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modularization_statistics
 version: !ruby/object:Gem::Version
-  version: 1.41.0
+  version: 1.43.0
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-14 00:00:00.000000000 Z
+date: 2022-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: package_protections
+  name: parse_packwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: parse_packwerk
+  name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
+  name: rubocop-packs
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -182,9 +182,9 @@ files:
 - lib/modularization_statistics/private/metrics/nested_packs.rb
 - lib/modularization_statistics/private/metrics/packages.rb
 - lib/modularization_statistics/private/metrics/packages_by_team.rb
-- lib/modularization_statistics/private/metrics/protection_usage.rb
+- lib/modularization_statistics/private/metrics/packwerk_checker_usage.rb
 - lib/modularization_statistics/private/metrics/public_usage.rb
-- lib/modularization_statistics/private/metrics/rubocop_protections_exclusions.rb
+- lib/modularization_statistics/private/metrics/rubocop_usage.rb
 - lib/modularization_statistics/private/source_code_file.rb
 - lib/modularization_statistics/tag.rb
 - lib/modularization_statistics/tags.rb
@@ -193,9 +193,9 @@ files:
 - sorbet/rbi/gems/code_teams@1.0.0.rbi
 - sorbet/rbi/gems/dogapi@1.45.0.rbi
 - sorbet/rbi/gems/manual.rbi
-- sorbet/rbi/gems/package_protections@1.4.0.rbi
 - sorbet/rbi/gems/parse_packwerk@0.14.0.rbi
 - sorbet/rbi/gems/rspec@3.10.0.rbi
+- sorbet/rbi/gems/rubocop-packs@0.0.20.rbi
 - sorbet/rbi/todo.rbi
 homepage: https://github.com/rubyatscale/modularization_statistics
 licenses:

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

@@ -1,149 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module ModularizationStatistics
-  module Private
-    module Metrics
-      class ProtectionUsage
-        extend T::Sig
-
-        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
-        def self.get_protections_metrics(prefix, packages, package_tags)
-          protected_packages = packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
-          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 do |p|
-                #
-                # This is temporarily in place until we migrate off of `package_protections` in favor of `rubocop-packs`.
-                # At that point, we want to delete this branch and instead it we'd probably have two separate branches.
-                # One branch would look at `enforce_x` and `metadata.enforce_x_strictly`.
-                # The other branch would look at `.pack_rubocop.yml`.
-                # Later on, we could generalize this so that it automatically incorporates new cops from `rubocop-packs`,
-                # or even new packwerk plugins.
-                #
-                # Regardless, we'll want to keep the way we are naming these behaviors for now to preserve historical trends in the data.
-                #
-                if p.metadata['protections']
-                  p.violation_behavior_for(protection.identifier) == violation_behavior
-                else
-                  should_count_package?(p.original_package, protection, violation_behavior)
-                end
-              end
-              GaugeMetric.for(metric_name, count_of_packages, package_tags)
-            end
-          end
-        end
-
-        #
-        # Later, when we remove package protections, we can make this simpler by iterating over
-        # packwerk checkers and rubocop packs specifically. That would let us use a common, simple
-        # strategy to get metrics for both of them. For the first iteration, we'll want to continue
-        # to map the old names of things to the "protection" names. After that, I think we will want to
-        # extract that mapping into a tool that transforms the metrics that can be optionally turned off
-        # so that we can see metrics that are more closely connected to the new API.
-        # e.g. instead of `all_packages.prevent_this_package_from_violating_its_stated_dependencies.fail_on_any.count`, we'd see
-        # e.g. instead of `all_packages.checkers.enforce_dependencies.strict.count`, we'd see
-        # e.g. instead of `all_packages.prevent_this_package_from_creating_other_namespaces.fail_on_new.count`, we'd see
-        # e.g. instead of `all_packages.cops.packs_namespaceconvention.true.count`, we'd see
-        # 
-        sig do
-          params(
-            package: ParsePackwerk::Package,
-            protection: PackageProtections::ProtectionInterface,
-            violation_behavior: PackageProtections::ViolationBehavior
-          ).returns(T::Boolean)
-        end
-        def self.should_count_package?(package, protection, violation_behavior)
-          if protection.identifier == 'prevent_this_package_from_violating_its_stated_dependencies'
-            strict_mode = package.metadata['enforce_dependencies_strictly']
-            enabled = package.enforces_dependencies?
-
-            case violation_behavior
-            when PackageProtections::ViolationBehavior::FailOnAny
-              !!strict_mode
-            when PackageProtections::ViolationBehavior::FailNever
-              !enabled
-            when PackageProtections::ViolationBehavior::FailOnNew
-              enabled && !strict_mode
-            else
-              T.absurd(violation_behavior)
-            end
-          elsif protection.identifier == 'prevent_other_packages_from_using_this_packages_internals'
-            strict_mode = package.metadata['enforce_privacy_strictly']
-            enabled = package.enforces_privacy?
-
-            case violation_behavior
-            when PackageProtections::ViolationBehavior::FailOnAny
-              !!strict_mode
-            when PackageProtections::ViolationBehavior::FailNever
-              !enabled
-            when PackageProtections::ViolationBehavior::FailOnNew
-              enabled && !strict_mode
-            else
-              T.absurd(violation_behavior)
-            end
-          elsif protection.identifier == 'prevent_other_packages_from_using_this_package_without_explicit_visibility'
-            case violation_behavior
-            when PackageProtections::ViolationBehavior::FailOnAny
-              # We'd probably not want to support this right away
-              false
-            when PackageProtections::ViolationBehavior::FailNever
-              # We'd need to add this to `parse_packwerk` so that we can get other arbitrary top-level keys.
-              # Alternatively we can put this in `metadata` for the time being to unblock us.
-              # package.config['enforce_visibility']
-              !package.metadata['enforce_visibility']
-            when PackageProtections::ViolationBehavior::FailOnNew
-              !!package.metadata['enforce_visibility']
-            else
-              T.absurd(violation_behavior)
-            end
-          else
-            # Otherwise, we're in a rubocop case
-            rubocop_yml_file = package.directory.join('.rubocop.yml')
-            return false if !rubocop_yml_file.exist?
-            rubocop_yml = YAML.load_file(rubocop_yml_file)
-            protection = T.cast(protection, PackageProtections::RubocopProtectionInterface)
-            # We will likely want a rubocop-packs API for this, to be able to ask if a cop is enabled for a pack.
-            # It's possible we will want to allow these to be enabled at the top-level `.rubocop.yml`,
-            # in which case we wouldn't get the right metrics with this approach. However, we can also accept
-            # that as a current limitation.
-            cop_map = {
-              'PackageProtections/TypedPublicApi' => 'Packs/TypedPublicApis',
-              'PackageProtections/NamespacedUnderPackageName' => 'Packs/RootNamespaceIsPackName',
-              'PackageProtections/OnlyClassMethods' => 'Packs/ClassMethodsAsPublicApis',
-              'PackageProtections/RequireDocumentedPublicApis' => 'Packs/DocumentedPublicApis',
-            }
-            # We want to use the cop names from `rubocop-packs`. Eventually, we'll just literate over these
-            # cop names directly, or ask `rubocop-packs` for the list of cops to care about.
-            cop_config = rubocop_yml[cop_map[protection.cop_name]]
-            return false if cop_config.nil?
-            enabled = cop_config['Enabled']
-            strict_mode = cop_config['FailureMode'] == 'strict'
-
-            case violation_behavior
-            when PackageProtections::ViolationBehavior::FailOnAny
-              !!strict_mode
-            when PackageProtections::ViolationBehavior::FailNever
-              !enabled
-            when PackageProtections::ViolationBehavior::FailOnNew
-              enabled && !strict_mode
-            else
-              T.absurd(violation_behavior)
-            end
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-module ModularizationStatistics
-  module Private
-    module Metrics
-      class RubocopProtectionsExclusions
-        extend T::Sig
-
-        sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
-        def self.get_rubocop_exclusions(prefix, packages, package_tags)
-          protected_packages = packages.map { |p| PackageProtections::ProtectedPackage.from(p) }
-
-          rubocop_based_package_protections = T.cast(PackageProtections.all.select { |p| p.is_a?(PackageProtections::RubocopProtectionInterface) }, T::Array[PackageProtections::RubocopProtectionInterface])
-          rubocop_based_package_protections.flat_map do |rubocop_based_package_protection|
-            metric_name = "#{prefix}.#{rubocop_based_package_protection.identifier}.rubocop_exclusions.count"
-            all_exclusions_count = ParsePackwerk.all.sum { |package| exclude_count_for_package_and_protection(package, rubocop_based_package_protection)}
-            GaugeMetric.for(metric_name, all_exclusions_count, package_tags)
-          end
-        end
-
-        # TODO: `rubocop-packs` may want to expose API for this
-        sig { params(package: ParsePackwerk::Package, protection: PackageProtections::RubocopProtectionInterface).returns(Integer) }
-        def self.exclude_count_for_package_and_protection(package, protection)
-          rubocop_todo = package.directory.join('.rubocop_todo.yml')
-          if rubocop_todo.exist?
-            loaded_rubocop_todo = YAML.load_file(rubocop_todo)
-            cop_config = loaded_rubocop_todo.fetch(protection.cop_name, {})
-            cop_config.fetch('Exclude', []).count
-          else
-            0
-          end
-        end
-      end
-    end
-  end
-end

data/sorbet/rbi/gems/package_protections@1.4.0.rbi

@@ -1,581 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `package_protections` gem.
-# Please instead update this file by running `bin/tapioca gem package_protections`.
-
-module PackageProtections
-  class << self
-    sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-    def all; end
-
-    sig { void }
-    def bust_cache!; end
-
-    sig { params(blk: T.proc.params(arg0: ::PackageProtections::Private::Configuration).void).void }
-    def configure(&blk); end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-    end
-    def get_offenses(packages:, new_violations:); end
-
-    sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
-    def private_cop_config(identifier); end
-
-    sig { params(root_pathname: ::Pathname).returns(::String) }
-    def rubocop_yml(root_pathname: T.unsafe(nil)); end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        protection_identifiers: T::Array[::String],
-        verbose: T::Boolean
-      ).void
-    end
-    def set_defaults!(packages, protection_identifiers: T.unsafe(nil), verbose: T.unsafe(nil)); end
-
-    sig { params(identifier: ::String).returns(::PackageProtections::ProtectionInterface) }
-    def with_identifier(identifier); end
-  end
-end
-
-PackageProtections::EXPECTED_PACK_DIRECTORIES = T.let(T.unsafe(nil), Array)
-PackageProtections::Identifier = T.type_alias { ::String }
-class PackageProtections::IncorrectPublicApiUsageError < ::StandardError; end
-
-class PackageProtections::Offense < ::T::Struct
-  const :file, ::String
-  const :message, ::String
-  const :package, ::ParsePackwerk::Package
-  const :violation_type, ::String
-
-  sig { returns(::String) }
-  def package_name; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-PackageProtections::PROTECTIONS_TODO_YML = T.let(T.unsafe(nil), String)
-
-class PackageProtections::PerFileViolation < ::T::Struct
-  const :class_name, ::String
-  const :constant_source_package, ::String
-  const :filepath, ::String
-  const :reference_source_package, ::ParsePackwerk::Package
-  const :type, ::String
-
-  sig { returns(T::Boolean) }
-  def dependency?; end
-
-  sig { returns(T::Boolean) }
-  def privacy?; end
-
-  class << self
-    sig do
-      params(
-        violation: ::ParsePackwerk::Violation,
-        reference_source_package: ::ParsePackwerk::Package
-      ).returns(T::Array[::PackageProtections::PerFileViolation])
-    end
-    def from(violation, reference_source_package); end
-
-    def inherited(s); end
-  end
-end
-
-module PackageProtections::Private
-  class << self
-    sig { returns(T::Array[::PackageProtections::ProtectedPackage]) }
-    def all_protected_packages; end
-
-    sig { void }
-    def bust_cache!; end
-
-    sig { returns(::PackageProtections::Private::Configuration) }
-    def config; end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-    end
-    def get_offenses(packages:, new_violations:); end
-
-    sig { params(name: ::String).returns(::PackageProtections::ProtectedPackage) }
-    def get_package_with_name(name); end
-
-    sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
-    def private_cop_config(identifier); end
-
-    sig { params(root_pathname: ::Pathname).returns(::String) }
-    def rubocop_yml(root_pathname:); end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        protection_identifiers: T::Array[::String],
-        verbose: T::Boolean
-      ).void
-    end
-    def set_defaults!(packages, protection_identifiers:, verbose:); end
-  end
-end
-
-class PackageProtections::Private::ColorizedString
-  sig { params(original_string: ::String, color: ::PackageProtections::Private::ColorizedString::Color).void }
-  def initialize(original_string, color = T.unsafe(nil)); end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def blue; end
-
-  sig { returns(::String) }
-  def colorized_to_s; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def green; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def light_blue; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def pink; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def red; end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def white; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def yellow; end
-
-  private
-
-  sig { returns(::Integer) }
-  def color_code; end
-
-  sig do
-    params(
-      color: ::PackageProtections::Private::ColorizedString::Color
-    ).returns(::PackageProtections::Private::ColorizedString)
-  end
-  def colorize(color); end
-end
-
-class PackageProtections::Private::ColorizedString::Color < ::T::Enum
-  enums do
-    Black = new
-    Red = new
-    Green = new
-    Yellow = new
-    Blue = new
-    Pink = new
-    LightBlue = new
-    White = new
-  end
-end
-
-class PackageProtections::Private::Configuration
-  sig { void }
-  def initialize; end
-
-  sig { void }
-  def bust_cache!; end
-
-  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-  def default_protections; end
-
-  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-  def protections; end
-
-  sig { params(protections: T::Array[::PackageProtections::ProtectionInterface]).void }
-  def protections=(protections); end
-end
-
-class PackageProtections::Private::IncomingPrivacyProtection
-  include ::PackageProtections::ProtectionInterface
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::IncomingPrivacyProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::Private::MetadataModifiers
-  class << self
-    sig do
-      params(
-        package: ::ParsePackwerk::Package,
-        protection_identifier: ::String,
-        violation_behavior: ::PackageProtections::ViolationBehavior
-      ).returns(::ParsePackwerk::Package)
-    end
-    def package_with_modified_protection(package, protection_identifier, violation_behavior); end
-  end
-end
-
-class PackageProtections::Private::OutgoingDependencyProtection
-  include ::PackageProtections::ProtectionInterface
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::OutgoingDependencyProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::Private::Output
-  class << self
-    sig { params(str: ::String).void }
-    def p(str); end
-
-    sig { params(str: ::PackageProtections::Private::ColorizedString, colorized: T::Boolean).void }
-    def p_colorized(str, colorized:); end
-  end
-end
-
-class PackageProtections::Private::VisibilityProtection
-  include ::PackageProtections::ProtectionInterface
-
-  sig { returns(::PackageProtections::ViolationBehavior) }
-  def default_behavior; end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::VisibilityProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::ProtectedPackage < ::T::Struct
-  const :deprecated_references, ::ParsePackwerk::DeprecatedReferences
-  const :original_package, ::ParsePackwerk::Package
-  const :protections, T::Hash[::String, ::PackageProtections::ViolationBehavior]
-
-  sig { returns(T::Array[::String]) }
-  def dependencies; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def metadata; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { params(key: ::String).returns(::PackageProtections::ViolationBehavior) }
-  def violation_behavior_for(key); end
-
-  sig { returns(T::Array[::ParsePackwerk::Violation]) }
-  def violations; end
-
-  sig { returns(T::Set[::String]) }
-  def visible_to; end
-
-  sig { returns(::Pathname) }
-  def yml; end
-
-  class << self
-    sig { params(original_package: ::ParsePackwerk::Package).returns(::PackageProtections::ProtectedPackage) }
-    def from(original_package); end
-
-    sig do
-      params(
-        protection: ::PackageProtections::ProtectionInterface,
-        metadata: T::Hash[T.untyped, T.untyped],
-        package: ::ParsePackwerk::Package
-      ).returns(::PackageProtections::ViolationBehavior)
-    end
-    def get_violation_behavior(protection, metadata, package); end
-
-    def inherited(s); end
-  end
-end
-
-module PackageProtections::ProtectionInterface
-  requires_ancestor { Kernel }
-
-  abstract!
-
-  sig { returns(::PackageProtections::ViolationBehavior) }
-  def default_behavior; end
-
-  sig do
-    params(
-      protected_packages: T::Array[::PackageProtections::ProtectedPackage],
-      new_violations: T::Array[::PackageProtections::PerFileViolation]
-    ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses(protected_packages, new_violations); end
-
-  sig do
-    abstract
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    abstract
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { abstract.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { abstract.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { abstract.returns(::String) }
-  def identifier; end
-
-  sig do
-    params(
-      behavior: ::PackageProtections::ViolationBehavior,
-      package: ::ParsePackwerk::Package
-    ).returns(T::Boolean)
-  end
-  def supports_violation_behavior?(behavior, package); end
-
-  sig do
-    abstract
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-end
-
-module PackageProtections::RubocopProtectionInterface
-  include ::PackageProtections::ProtectionInterface
-
-  abstract!
-
-  sig do
-    params(
-      packages: T::Array[::PackageProtections::ProtectedPackage]
-    ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
-  end
-  def cop_configs(packages); end
-
-  sig { abstract.returns(::String) }
-  def cop_name; end
-
-  sig { params(package: ::PackageProtections::ProtectedPackage).returns(T::Hash[T.untyped, T.untyped]) }
-  def custom_cop_config(package); end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { abstract.returns(T::Array[::String]) }
-  def included_globs_for_pack; end
-
-  sig { abstract.params(file: ::String).returns(::String) }
-  def message_for_fail_on_any(file); end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(rule: ::String).returns(T::Set[::String]) }
-  def exclude_for_rule(rule); end
-
-  class << self
-    sig { void }
-    def bust_rubocop_todo_yml_cache; end
-
-    sig { returns(T.untyped) }
-    def rubocop_todo_yml; end
-  end
-end
-
-class PackageProtections::RubocopProtectionInterface::CopConfig < ::T::Struct
-  const :enabled, T::Boolean, default: T.unsafe(nil)
-  const :exclude_paths, T::Array[::String], default: T.unsafe(nil)
-  const :include_paths, T::Array[::String], default: T.unsafe(nil)
-  const :name, ::String
-
-  sig { returns(::String) }
-  def to_rubocop_yml_compatible_format; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class PackageProtections::ViolationBehavior < ::T::Enum
-  enums do
-    FailOnAny = new
-    FailOnNew = new
-    FailNever = new
-  end
-
-  sig { returns(T::Boolean) }
-  def enabled?; end
-
-  sig { returns(T::Boolean) }
-  def fail_never?; end
-
-  sig { returns(T::Boolean) }
-  def fail_on_any?; end
-
-  sig { returns(T::Boolean) }
-  def fail_on_new?; end
-
-  class << self
-    sig { params(value: T.untyped).returns(::PackageProtections::ViolationBehavior) }
-    def from_raw_value(value); end
-  end
-end
-
-module RuboCop; end
-module RuboCop::Cop; end
-module RuboCop::Cop::PackageProtections; end