packwerk-extensions 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dcb5ef4db4ff6cf134b8707feb0cb4009c8e38db338c407bcbf1fa88da19f79e
+  data.tar.gz: 59e1d1382dba41b33924eb82e679a830ccd642446a52748afabcd2d86b7f64b2
+SHA512:
+  metadata.gz: 3873288311271201955075edbf6fe17af585cf62efd1b5d925908e1f7791a45cf1b19e6c4bce29ab5d2bc624ed3eaacece6bf0a153f98051261408a8c2ec1d58
+  data.tar.gz: 4651d546fa1aff7e1c4521c5311711d7598d9f2defb621132172d1a3058a3d7b15bddfde40e67f8e658490df1616ff90ad14e2fc45e18d0383a7f67f3331c4a2

data/README.md

@@ -0,0 +1,66 @@
+# packwerk-extensions
+
+`packwerk-extensions` is a home for checker extensions for packwerk.
+
+#### Enforcing privacy boundary
+
+The privacy checker extension was originally extracted from [packwerk](https://github.com/Shopify/packwerk).
+
+A package's privacy boundary is violated when there is a reference to the package's private constants from a source outside the package.
+
+There are two ways you can enforce privacy for your package:
+
+1. Enforce privacy for all external sources
+
+```yaml
+# components/merchandising/package.yml
+enforce_privacy: true  # will make everything private that is not in
+                        # the components/merchandising/app/public folder
+```
+
+Setting `enforce_privacy` to true will make all references to private constants in your package a violation.
+
+2. Enforce privacy for specific constants
+
+```yaml
+# components/merchandising/package.yml
+enforce_privacy:
+  - "::Merchandising::Product"
+  - "::SomeNamespace"  # enforces privacy for the namespace and
+                       # everything nested in it
+```
+
+It will be a privacy violation when a file outside of the `components/merchandising` package tries to reference `Merchandising::Product`.
+
+##### Using public folders
+You may enforce privacy either way mentioned above and still expose a public API for your package by placing constants in the public folder, which by default is `app/public`. The constants in the public folder will be made available for use by the rest of the application.
+
+##### Defining your own public folder
+
+You may prefer to override the default public folder, you can do so on a per-package basis by defining a `public_path`.
+
+Example:
+
+```yaml
+public_path: my/custom/path/
+```
+
+### Package Privacy violation
+A constant that is private to its package has been referenced from outside of the package. Constants are declared private in their package’s `package.yml`.
+
+See: [USAGE.md - Enforcing privacy boundary](USAGE.md#Enforcing-privacy-boundary)
+
+#### Interpreting Privacy violation
+
+> /Users/JaneDoe/src/github.com/sample-project/user/app/controllers/labels_controller.rb:170:30
+> Privacy violation: '::Billing::CarrierInvoiceTransaction' is private to 'billing' but referenced from 'user'.
+> Is there a public entrypoint in 'billing/app/public/' that you can use instead?
+>
+> Inference details: 'Billing::CarrierInvoiceTransaction' refers to ::Billing::CarrierInvoiceTransaction which seems to be defined in billing/app/models/billing/carrier_invoice_transaction.rb.
+
+There has been a privacy violation of the package `billing` in the package `user`, through the use of the constant `Billing::CarrierInvoiceTransaction` in the file `user/app/controllers/labels_controller.rb`.
+
+##### Suggestions
+You may be accessing the implementation of a piece of functionality that is supposed to be accessed through a public interface on the package. Try to use the public interface instead. A package’s public interface should be defined in its `app/public` folder and documented.
+
+The functionality you’re looking for may not be intended to be reused across packages at all. If there is no public interface for it but you have a good reason to use it from outside of its package, find the people responsible for the package and discuss a solution with them.

data/lib/packwerk/privacy/checker.rb

@@ -0,0 +1,99 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Privacy
+    # Checks whether a given reference references a private constant of another package.
+    class Checker
+      extend T::Sig
+      include Packwerk::Checker
+
+      VIOLATION_TYPE = T.let('privacy', String)
+
+      sig { override.returns(String) }
+      def violation_type
+        VIOLATION_TYPE
+      end
+
+      sig do
+        override
+          .params(reference: Packwerk::Reference)
+          .returns(T::Boolean)
+      end
+      def invalid_reference?(reference)
+        constant_package = reference.constant.package
+        privacy_package = Package.from(constant_package)
+
+        return false if privacy_package.public_path?(reference.constant.location)
+
+        privacy_option = privacy_package.enforce_privacy
+        return false if enforcement_disabled?(privacy_option)
+
+        return false unless privacy_option == true || privacy_option == 'strict' ||
+                            explicitly_private_constant?(reference.constant, explicitly_private_constants: T.unsafe(privacy_option))
+
+        true
+      end
+
+      sig do
+        override
+          .params(listed_offense: Packwerk::ReferenceOffense)
+          .returns(T::Boolean)
+      end
+      def strict_mode_violation?(listed_offense)
+        publishing_package = listed_offense.reference.constant.package
+        publishing_package.config['enforce_privacy'] == 'strict'
+      end
+
+      sig do
+        override
+          .params(reference: Packwerk::Reference)
+          .returns(String)
+      end
+      def message(reference)
+        source_desc = "'#{reference.package}'"
+
+        message = <<~MESSAGE
+          Privacy violation: '#{reference.constant.name}' is private to '#{reference.constant.package}' but referenced from #{source_desc}.
+          Is there a public entrypoint in '#{Package.from(reference.constant.package).public_path}' that you can use instead?
+
+          #{standard_help_message(reference)}
+        MESSAGE
+
+        message.chomp
+      end
+
+      private
+
+      sig do
+        params(
+          constant: ConstantDiscovery::ConstantContext,
+          explicitly_private_constants: T::Array[String]
+        ).returns(T::Boolean)
+      end
+      def explicitly_private_constant?(constant, explicitly_private_constants:)
+        explicitly_private_constants.include?(constant.name) ||
+          # nested constants
+          explicitly_private_constants.any? { |epc| constant.name.start_with?("#{epc}::") }
+      end
+
+      sig do
+        params(privacy_option: T.nilable(T.any(T::Boolean, String, T::Array[String])))
+          .returns(T::Boolean)
+      end
+      def enforcement_disabled?(privacy_option)
+        [false, nil].include?(privacy_option)
+      end
+
+      sig { params(reference: Reference).returns(String) }
+      def standard_help_message(reference)
+        standard_message = <<~MESSAGE.chomp
+          Inference details: this is a reference to #{reference.constant.name} which seems to be defined in #{reference.constant.location}.
+          To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
+        MESSAGE
+
+        standard_message.chomp
+      end
+    end
+  end
+end

data/lib/packwerk/privacy/package.rb

@@ -0,0 +1,51 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Privacy
+    class Package < T::Struct
+      extend T::Sig
+
+      const :public_path, String
+      const :user_defined_public_path, T.nilable(String)
+      const :enforce_privacy, T.nilable(T.any(T::Boolean, String, T::Array[String]))
+
+      sig { params(path: String).returns(T::Boolean) }
+      def public_path?(path)
+        path.start_with?(public_path)
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { params(package: ::Packwerk::Package).returns(Package) }
+        def from(package)
+          Package.new(
+            public_path: public_path_for(package),
+            user_defined_public_path: user_defined_public_path(package),
+            enforce_privacy: package.config['enforce_privacy']
+          )
+        end
+
+        sig { params(package: ::Packwerk::Package).returns(T.nilable(String)) }
+        def user_defined_public_path(package)
+          return unless package.config['public_path']
+          return package.config['public_path'] if package.config['public_path'].end_with?('/')
+
+          "#{package.config['public_path']}/"
+        end
+
+        sig { params(package: ::Packwerk::Package).returns(String) }
+        def public_path_for(package)
+          unprefixed_public_path = user_defined_public_path(package) || 'app/public/'
+
+          if package.root?
+            unprefixed_public_path
+          else
+            File.join(package.name, unprefixed_public_path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/privacy/validator.rb

@@ -0,0 +1,133 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Privacy
+    class Validator
+      extend T::Sig
+      include Packwerk::Validator
+
+      sig { override.params(package_set: PackageSet, configuration: Configuration).returns(ApplicationValidator::Result) }
+      def call(package_set, configuration)
+        privacy_settings = package_manifests_settings_for(configuration, 'enforce_privacy')
+
+        resolver = ConstantResolver.new(
+          root_path: configuration.root_path,
+          load_paths: configuration.load_paths
+        )
+
+        results = T.let([], T::Array[ApplicationValidator::Result])
+
+        privacy_settings.each do |config_file_path, setting|
+          results << check_enforce_privacy_setting(config_file_path, setting)
+          next unless setting.is_a?(Array)
+
+          constants = setting
+
+          results += assert_constants_can_be_loaded(constants, config_file_path)
+
+          constant_locations = constants.map { |c| [c, resolver.resolve(c)&.location] }
+
+          constant_locations.each do |name, location|
+            results << if location
+                         check_private_constant_location(configuration, package_set, name, location, config_file_path)
+                       else
+                         private_constant_unresolvable(name, config_file_path)
+                       end
+          end
+        end
+
+        public_path_settings = package_manifests_settings_for(configuration, 'public_path')
+        public_path_settings.each do |config_file_path, setting|
+          results << check_public_path(config_file_path, setting)
+        end
+
+        merge_results(results, separator: "\n---\n")
+      end
+
+      sig { override.returns(T::Array[String]) }
+      def permitted_keys
+        %w[public_path enforce_privacy]
+      end
+
+      private
+
+      sig do
+        params(config_file_path: String, setting: T.untyped).returns(ApplicationValidator::Result)
+      end
+      def check_public_path(config_file_path, setting)
+        if setting.is_a?(String) || setting.nil?
+          ApplicationValidator::Result.new(ok: true)
+        else
+          ApplicationValidator::Result.new(
+            ok: false,
+            error_value: "'public_path' option must be a string in #{config_file_path.inspect}: #{setting.inspect}"
+          )
+        end
+      end
+
+      sig do
+        params(config_file_path: String, setting: T.untyped).returns(ApplicationValidator::Result)
+      end
+      def check_enforce_privacy_setting(config_file_path, setting)
+        if [TrueClass, FalseClass, Array, NilClass].include?(setting.class)
+          ApplicationValidator::Result.new(ok: true)
+        else
+          ApplicationValidator::Result.new(
+            ok: false,
+            error_value: "Invalid 'enforce_privacy' option in #{config_file_path.inspect}: #{setting.inspect}"
+          )
+        end
+      end
+
+      sig do
+        params(configuration: Configuration, package_set: PackageSet, name: T.untyped, location: T.untyped,
+               config_file_path: T.untyped).returns(ApplicationValidator::Result)
+      end
+      def check_private_constant_location(configuration, package_set, name, location, config_file_path)
+        declared_package = package_set.package_from_path(relative_path(configuration, config_file_path))
+        constant_package = package_set.package_from_path(location)
+
+        if constant_package == declared_package
+          ApplicationValidator::Result.new(ok: true)
+        else
+          ApplicationValidator::Result.new(
+            ok: false,
+            error_value: "'#{name}' is declared as private in the '#{declared_package}' package but appears to be " \
+                         "defined\nin the '#{constant_package}' package. Packwerk resolved it to #{location}."
+          )
+        end
+      end
+
+      sig { params(constants: T.untyped, config_file_path: String).returns(T::Array[ApplicationValidator::Result]) }
+      def assert_constants_can_be_loaded(constants, config_file_path)
+        constants.map do |constant|
+          if constant.start_with?('::')
+            constant.try(&:constantize) && ApplicationValidator::Result.new(ok: true)
+          else
+            error_value = "'#{constant}', listed in the 'enforce_privacy' option " \
+                          "in #{config_file_path}, is invalid.\nPrivate constants need to be " \
+                          'prefixed with the top-level namespace operator `::`.'
+            ApplicationValidator::Result.new(
+              ok: false,
+              error_value: error_value
+            )
+          end
+        end
+      end
+
+      sig { params(name: T.untyped, config_file_path: T.untyped).returns(ApplicationValidator::Result) }
+      def private_constant_unresolvable(name, config_file_path)
+        explicit_filepath = "#{(name.start_with?('::') ? name[2..] : name).underscore}.rb"
+
+        ApplicationValidator::Result.new(
+          ok: false,
+          error_value: "'#{name}', listed in #{config_file_path}, could not be resolved.\n" \
+                       "This is probably because it is an autovivified namespace - a namespace module that doesn't have a\n" \
+                       "file explicitly defining it. Packwerk currently doesn't support declaring autovivified namespaces as\n" \
+                       "private. Add a #{explicit_filepath} file to explicitly define the constant."
+        )
+      end
+    end
+  end
+end

data/lib/packwerk/visibility/checker.rb

@@ -0,0 +1,93 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Visibility
+    # Checks whether a given reference references a constant from a package that does not permit visibility
+    class Checker
+      extend T::Sig
+      include Packwerk::Checker
+
+      VIOLATION_TYPE = T.let('visibility', String)
+
+      sig { override.returns(String) }
+      def violation_type
+        VIOLATION_TYPE
+      end
+
+      sig do
+        override
+          .params(reference: Packwerk::Reference)
+          .returns(T::Boolean)
+      end
+      def invalid_reference?(reference)
+        constant_package = reference.constant.package
+        visibility_package = Package.from(constant_package)
+        visibility_option = visibility_package.enforce_visibility
+        return false if enforcement_disabled?(visibility_option)
+
+        !visibility_package.visible_to.include?(reference.package.name)
+      end
+
+      sig do
+        override
+          .params(listed_offense: Packwerk::ReferenceOffense)
+          .returns(T::Boolean)
+      end
+      def strict_mode_violation?(listed_offense)
+        publishing_package = listed_offense.reference.constant.package
+        publishing_package.config['enforce_visibility'] == 'strict'
+      end
+
+      sig do
+        override
+          .params(reference: Packwerk::Reference)
+          .returns(String)
+      end
+      def message(reference)
+        source_desc = "'#{reference.package}'"
+
+        message = <<~MESSAGE
+          Visibility violation: '#{reference.constant.name}' belongs to '#{reference.constant.package}', which is not visible to #{source_desc}.
+          Is there a different package to use instead, or should '#{reference.constant.package}' also be visible to #{source_desc}?
+
+          #{standard_help_message(reference)}
+        MESSAGE
+
+        message.chomp
+      end
+
+      private
+
+      sig do
+        params(
+          constant: ConstantDiscovery::ConstantContext,
+          explicitly_private_constants: T::Array[String]
+        ).returns(T::Boolean)
+      end
+      def explicitly_private_constant?(constant, explicitly_private_constants:)
+        explicitly_private_constants.include?(constant.name) ||
+          # nested constants
+          explicitly_private_constants.any? { |epc| constant.name.start_with?("#{epc}::") }
+      end
+
+      sig do
+        params(visibility_option: T.nilable(T.any(T::Boolean, String)))
+          .returns(T::Boolean)
+      end
+      def enforcement_disabled?(visibility_option)
+        [false, nil].include?(visibility_option)
+      end
+
+      sig { params(reference: Reference).returns(String) }
+      def standard_help_message(reference)
+        standard_message = <<~MESSAGE.chomp
+          Inference details: this is a reference to #{reference.constant.name} which seems to be defined in #{reference.constant.location}.
+          To receive help interpreting or resolving this error message, see: https://github.com/Shopify/packwerk/blob/main/TROUBLESHOOT.md#Troubleshooting-violations
+        MESSAGE
+
+        standard_message.chomp
+      end
+    end
+  end
+end

data/lib/packwerk/visibility/package.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Visibility
+    class Package < T::Struct
+      extend T::Sig
+
+      const :visible_to, T::Array[String]
+      const :enforce_visibility, T.nilable(T.any(T::Boolean, String))
+
+      class << self
+        extend T::Sig
+
+        sig { params(package: ::Packwerk::Package).returns(Package) }
+        def from(package)
+          Package.new(
+            visible_to: package.config['visible_to'] || [],
+            enforce_visibility: package.config['enforce_visibility']
+          )
+        end
+      end
+    end
+  end
+end

data/lib/packwerk/visibility/validator.rb

@@ -0,0 +1,57 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Packwerk
+  module Visibility
+    class Validator
+      extend T::Sig
+      include Packwerk::Validator
+
+      sig { override.params(package_set: PackageSet, configuration: Configuration).returns(ApplicationValidator::Result) }
+      def call(package_set, configuration)
+        visible_settings = package_manifests_settings_for(configuration, 'visible_to')
+        results = T.let([], T::Array[ApplicationValidator::Result])
+
+        all_package_names = package_set.map(&:name).to_set
+
+        package_manifests_settings_for(configuration, 'enforce_visibility').each do |config, setting|
+          next if setting.nil?
+
+          next if [TrueClass, FalseClass, 'strict'].include?(setting.class)
+
+          results << ApplicationValidator::Result.new(
+            ok: false,
+            error_value: "\tInvalid 'enforce_visibility' option: #{setting.inspect} in #{config.inspect}"
+          )
+        end
+
+        visible_settings.each do |config_file_path, setting|
+          next if setting.nil?
+
+          if setting.is_a?(Array)
+            packages_not_found = setting.to_set - all_package_names
+
+            if packages_not_found.any?
+              results << ApplicationValidator::Result.new(
+                ok: false,
+                error_value: "'visible_to' option must only contain valid packages in #{config_file_path.inspect}. Invalid packages: #{packages_not_found.to_a.inspect}"
+              )
+            end
+          else
+            results << ApplicationValidator::Result.new(
+              ok: false,
+              error_value: "'visible_to' option must be an array in #{config_file_path.inspect}."
+            )
+          end
+        end
+
+        merge_results(results, separator: "\n---\n")
+      end
+
+      sig { override.returns(T::Array[String]) }
+      def permitted_keys
+        %w[visible_to enforce_visibility]
+      end
+    end
+  end
+end

data/lib/packwerk-extensions.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'sorbet-runtime'
+require 'packwerk'
+
+require 'packwerk/privacy/checker'
+require 'packwerk/privacy/package'
+require 'packwerk/privacy/validator'
+
+require 'packwerk/visibility/checker'
+require 'packwerk/visibility/package'
+require 'packwerk/visibility/validator'
+
+module Packwerk
+  module Extensions
+  end
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: packwerk-extensions
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gusto Engineers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-12-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: packwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.2.1
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sorbet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+- !ruby/object:Gem::Dependency
+  name: sorbet-static
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.5.10520
+- !ruby/object:Gem::Dependency
+  name: tapioca
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A collection of extensions for packwerk packages.
+email:
+- dev@gusto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/packwerk-extensions.rb
+- lib/packwerk/privacy/checker.rb
+- lib/packwerk/privacy/package.rb
+- lib/packwerk/privacy/validator.rb
+- lib/packwerk/visibility/checker.rb
+- lib/packwerk/visibility/package.rb
+- lib/packwerk/visibility/validator.rb
+homepage: https://github.com/rubyatscale/packwerk-extensions
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/rubyatscale/packwerk-extensions
+  source_code_uri: https://github.com/rubyatscale/packwerk-extensions
+  changelog_uri: https://github.com/rubyatscale/packwerk-extensions/releases
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: A collection of extensions for packwerk packages.
+test_files: []