modularization_statistics 1.40.0 → 1.42.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d2ee852554f37feac4459bf6693e0d33c2548a7c1ee8e61de4bfe84e74e7349
-  data.tar.gz: abe5cc4fb463ba76e0574826f8de32c3bba0e5c825099e246ec543a570b4edb2
+  metadata.gz: 79da508fe87219aecb90819b7b1cb7c1681108e8938fc48079d2dac98de6b998
+  data.tar.gz: 408f7f9f5bef70a3e11f8022cd7c6a328ad744095625aa94fc1af4757177c903
 SHA512:
-  metadata.gz: 3e779207990c24242ac661f2760c7f20c7d9e01f0198309491e6a65e69dceb6adb0272f34d7b5ea0b52a46f9b7dbd559842ad1ad6771b9f3b0a860a1ca7a2c92
-  data.tar.gz: 24a15392b40e998f2b7d6c3a1114513245fce0a35ca40d4c28caf0ffdae4f0d2054dfcfb5cee706723b7a4905e5423b52cc46423804f8bfa2510822658a22984
+  metadata.gz: fdd4ec7596f32e10267deb3bb1a75c3a84e4269b583317a9879ce7e992caaf2503daf20b64c27f1471395e51f0d575d3ef6aa1bf424ce53af3f71b75f7a6df7d
+  data.tar.gz: ec1c565bf1c3a5e01fea05a8fa128ac35519adbb58939ef787dca80b2c6db1e5054f6407ef619cde00efacaa5395827aac8c8b4f5690efb8e518e6d0888f7340

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/metrics/protection_usage.rb

@@ -93,24 +93,9 @@ module ModularizationStatistics
             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')
+            rubocop_yml_file = package.directory.join(RuboCop::Packs::PACK_LEVEL_RUBOCOP_YML)
             return false if !rubocop_yml_file.exist?
             rubocop_yml = YAML.load_file(rubocop_yml_file)
             protection = T.cast(protection, PackageProtections::RubocopProtectionInterface)
@@ -119,10 +104,10 @@ module ModularizationStatistics
             # 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/TypedPublicApi' => 'Packs/TypedPublicApis',
+              'PackageProtections/NamespacedUnderPackageName' => 'Packs/RootNamespaceIsPackName',
               'PackageProtections/OnlyClassMethods' => 'Packs/ClassMethodsAsPublicApis',
-              'PackageProtections/RequireDocumentedPublicApis' => 'Packs/RequireDocumentedPublicApis',
+              '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.

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

@@ -22,7 +22,12 @@ module ModularizationStatistics
         # 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 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(protection.cop_name, {})

data/sorbet/rbi/gems/{package_protections@1.4.0.rbi → package_protections@4.0.1.rbi}

@@ -12,6 +12,9 @@ module PackageProtections
     sig { void }
     def bust_cache!; end
 
+    sig { returns(::PackageProtections::Private::Configuration) }
+    def config; end
+
     sig { params(blk: T.proc.params(arg0: ::PackageProtections::Private::Configuration).void).void }
     def configure(&blk); end
 
@@ -23,9 +26,6 @@ module PackageProtections
     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
 
@@ -38,6 +38,9 @@ module PackageProtections
     end
     def set_defaults!(packages, protection_identifiers: T.unsafe(nil), verbose: T.unsafe(nil)); end
 
+    sig { returns(T::Array[::String]) }
+    def validate!; end
+
     sig { params(identifier: ::String).returns(::PackageProtections::ProtectionInterface) }
     def with_identifier(identifier); end
   end
@@ -97,9 +100,6 @@ module PackageProtections::Private
     sig { void }
     def bust_cache!; end
 
-    sig { returns(::PackageProtections::Private::Configuration) }
-    def config; end
-
     sig do
       params(
         packages: T::Array[::ParsePackwerk::Package],
@@ -111,8 +111,8 @@ module PackageProtections::Private
     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 { void }
+    def load_client_configuration; end
 
     sig { params(root_pathname: ::Pathname).returns(::String) }
     def rubocop_yml(root_pathname:); end
@@ -189,17 +189,26 @@ class PackageProtections::Private::Configuration
   sig { void }
   def initialize; end
 
+  sig { returns(T::Array[::String]) }
+  def acceptable_parent_classes; end
+
+  def acceptable_parent_classes=(_arg0); end
+
   sig { void }
   def bust_cache!; end
 
   sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
   def default_protections; end
 
+  sig { returns(T::Array[::String]) }
+  def globally_permitted_namespaces; end
+
+  def globally_permitted_namespaces=(_arg0); end
+
   sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
   def protections; end
 
-  sig { params(protections: T::Array[::PackageProtections::ProtectionInterface]).void }
-  def protections=(protections); end
+  def protections=(_arg0); end
 end
 
 class PackageProtections::Private::IncomingPrivacyProtection
@@ -321,57 +330,6 @@ class PackageProtections::Private::Output
   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
@@ -392,9 +350,6 @@ class PackageProtections::ProtectedPackage < ::T::Struct
   sig { returns(T::Array[::ParsePackwerk::Violation]) }
   def violations; end
 
-  sig { returns(T::Set[::String]) }
-  def visible_to; end
-
   sig { returns(::Pathname) }
   def yml; end
 
@@ -489,8 +444,8 @@ module PackageProtections::RubocopProtectionInterface
   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 { returns(T::Hash[T.untyped, T.untyped]) }
+  def custom_cop_config; end
 
   sig do
     override
@@ -522,25 +477,13 @@ module PackageProtections::RubocopProtectionInterface
       ).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 :metadata, T.untyped, default: T.unsafe(nil)
   const :name, ::String
 
   sig { returns(::String) }
@@ -579,3 +522,5 @@ end
 module RuboCop; end
 module RuboCop::Cop; end
 module RuboCop::Cop::PackageProtections; end
+
+RuboCop::Cop::PackageProtections::OnlyClassMethods::IDENTIFIER = T.let(T.unsafe(nil), String)

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.40.0
+  version: 1.42.0
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-11-04 00:00:00.000000000 Z
+date: 2022-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -193,9 +193,10 @@ 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/package_protections@4.0.1.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: