modularization_statistics 1.37.0 → 1.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 252db0bdd5ec50e555d34ce4c7468df4a5bf731274fafd137a319eaf1a1100b9
-  data.tar.gz: 8983a207179da6a93b34464f98c3b478a23087b34946f63d4c1cf95992d10f9e
+  metadata.gz: c11bc9704708d387bff6b5d7245832c6d57c9291a7dcc306513e3942afb53311
+  data.tar.gz: 7d5403d37a5811f5ef1798a3a8bfb96b304124ada289b75dba14db0844fd252e
 SHA512:
-  metadata.gz: cebc018b3841416b6194e3cef53779f3529f2d56463bbd8c6d79a6fb322f9c1c1a81d0a357fb8140cd48853abe6d5d1de160e707414b2d71eccbdbbb36dc9993
-  data.tar.gz: d837d652fed0baca80bfc6e1613d1ab75e1ac5b5b7d798c7df544a53e3c27c5c20ab82d8d39891aa29034541086d0e6a6b3e806d22b5b575c836951a1f96cac7
+  metadata.gz: 2c82a234d983ddc50d494f6eb8933633a0b61a7e82783d375f5d22b02c1e12fb476f9fb70ca35885ecadc879dd1fc94179cf6db3b1d52f47501afe38c6349651
+  data.tar.gz: ec00762292cdec0eb441ad424bdd5e80733a9acd418925f82c92142988df9d4b3b6843b8e4de1d9b8190e48cf23f6818b2e4f7176bf263a6541fa490181c38b0

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

@@ -17,36 +17,34 @@ module ModularizationStatistics
           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.dependency_violations.count', packages.sum { |package| Metrics.file_count(package.violations.select(&:dependency?)) }, package_tags)
+          all_metrics << GaugeMetric.for('all_packages.privacy_violations.count', 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 << GaugeMetric.for('all_packages.with_violations.count', 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 += Metrics::RubocopProtectionsExclusions.get_rubocop_exclusions('all_packages', protected_packages, 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 << 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)
+          inbound_violations_by_package = packages.flat_map(&:violations).group_by(&:to_package_name)
 
-          protected_packages.each do |protected_package|
-            package = protected_package.original_package
+          packages.each do |package|
             package_tags = Metrics.tags_for_package(package, app_name)
 
             #
             # VIOLATIONS (implicit dependencies)
             #
-            outbound_violations = protected_package.violations
+            outbound_violations = 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?)
@@ -62,7 +60,7 @@ module ModularizationStatistics
 
             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|
+            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}"

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

@@ -16,25 +16,25 @@ module ModularizationStatistics
         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|
+
+          all_packages.group_by { |package| CodeOwnership.for_package(package)&.name }.each do |team_name, 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)
+            inbound_violations_by_package = all_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.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::PublicUsage.get_public_usage_metrics('by_team', packages_by_team, 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)
+            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)
+            all_metrics << GaugeMetric.for('by_team.notify_on_new_violations.count', 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)
+            outbound_violations = 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] || [] }
+            inbound_violations = 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?)
 
@@ -47,7 +47,7 @@ module ModularizationStatistics
             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)
+            all_metrics << GaugeMetric.for('by_team.has_readme.count', packages_by_team.count { |package| Metrics.has_readme?(package) }, team_tags)
 
             grouped_outbound_violations = outbound_violations.group_by do |violation|
               to_package = ParsePackwerk.find(violation.to_package_name)

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

@@ -7,8 +7,9 @@ module ModularizationStatistics
       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)
+        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.
@@ -22,11 +23,126 @@ module ModularizationStatistics
               }
               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 }
+              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.strictly_enforce_x`.
+                # 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['strictly_enforce_dependencies']
+            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['strictly_enforce_privacy']
+            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/TypedPublicApi',
+              'PackageProtections/NamespacedUnderPackageName' => 'Packs/NamespaceConvention',
+              'PackageProtections/OnlyClassMethods' => 'Packs/ClassMethodsAsPublicApis',
+              'PackageProtections/RequireDocumentedPublicApis' => 'Packs/RequireDocumentedPublicApis',
+            }
+            # 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

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

@@ -7,8 +7,10 @@ module ModularizationStatistics
       class RubocopProtectionsExclusions
         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_rubocop_exclusions(prefix, protected_packages, package_tags)
+        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"
@@ -17,6 +19,7 @@ module ModularizationStatistics
           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')

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

@@ -15,7 +15,7 @@ module ParsePackwerk
     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)) }
+    sig { params(file_path: T.any(::Pathname, ::String)).returns(::ParsePackwerk::Package) }
     def package_from_path(file_path); end
 
     sig { params(package: ::ParsePackwerk::Package).void }
@@ -51,6 +51,7 @@ end
 
 ParsePackwerk::DEFAULT_EXCLUDE_GLOBS = T.let(T.unsafe(nil), Array)
 ParsePackwerk::DEFAULT_PACKAGE_PATHS = T.let(T.unsafe(nil), Array)
+ParsePackwerk::DEFAULT_PUBLIC_PATH = T.let(T.unsafe(nil), String)
 ParsePackwerk::DEPENDENCIES = T.let(T.unsafe(nil), String)
 ParsePackwerk::DEPRECATED_REFERENCES_YML_NAME = T.let(T.unsafe(nil), String)
 
@@ -81,6 +82,7 @@ end
 
 ParsePackwerk::PACKAGE_YML_NAME = T.let(T.unsafe(nil), String)
 ParsePackwerk::PACKWERK_YML_NAME = T.let(T.unsafe(nil), String)
+ParsePackwerk::PUBLIC_PATH = T.let(T.unsafe(nil), String)
 
 class ParsePackwerk::Package < ::T::Struct
   const :dependencies, T::Array[::String]
@@ -88,6 +90,7 @@ class ParsePackwerk::Package < ::T::Struct
   const :enforce_privacy, T::Boolean
   const :metadata, T::Hash[T.untyped, T.untyped]
   const :name, ::String
+  const :public_path, ::String, default: T.unsafe(nil)
 
   sig { returns(::Pathname) }
   def directory; end
@@ -98,6 +101,12 @@ class ParsePackwerk::Package < ::T::Struct
   sig { returns(T::Boolean) }
   def enforces_privacy?; end
 
+  sig { returns(::Pathname) }
+  def public_directory; end
+
+  sig { returns(T::Array[::ParsePackwerk::Violation]) }
+  def violations; end
+
   sig { returns(::Pathname) }
   def yml; end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: modularization_statistics
 version: !ruby/object:Gem::Version
-  version: 1.37.0
+  version: 1.39.0
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-09-07 00:00:00.000000000 Z
+date: 2022-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -194,7 +194,7 @@ files:
 - 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.12.0.rbi
+- sorbet/rbi/gems/parse_packwerk@0.14.0.rbi
 - sorbet/rbi/gems/rspec@3.10.0.rbi
 - sorbet/rbi/todo.rbi
 homepage: https://github.com/rubyatscale/modularization_statistics
@@ -220,7 +220,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A gem to collect statistics about modularization progress in a Rails application