rubocop-packs 0.0.10 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3aa6a83103635cffaf57bbe3187211f14b0981633a55cf04cd73f6261df3d83a
-  data.tar.gz: 8816eab16fe3dd069a3327b8f1569e910ea07a012bb97bead1baf0f7f6cdfc66
+  metadata.gz: 23ba4ef8b1719f4a38ac54f304efb11c88df874e3ba15888ad83fd6e3d0b78e1
+  data.tar.gz: 1b2c369b9f7f34dfa6439724a5b2a4dc39addeb1843f8d24d001a9dc55be1860
 SHA512:
-  metadata.gz: 37e828c802da1563049ce07a05e224187bfe8a3d61861f0cc05e774c311a3627d66d6ff116480d44100a9d31ef756bde1ea16777e02e5517e8f31fb0aab77595
-  data.tar.gz: 2e54cf17766e69bfd81663a488f1171a74335dd71c55fbfc55f9d1334f6eeae5d0b0fd5e7134349b42fb61c749520a760fd1902f0dfe19c457c311cba55f10ca
+  metadata.gz: 16a8330e4f3649d6e37178759e23eb500dec1d152b13b8a46e1c0b33ebb8c6f4369c1e4683d1c8ab44ca58b987cedcb567a7e0692aae80744022cc0496d781c8
+  data.tar.gz: c022df83da7b9c811a0add0c6a13950fbb65b7289f2e687093df1aa2c3900b23aacac0e50f72d3d89deb350d94c055b98a198001692498a394ee31136c3e3e65

data/README.md

@@ -61,6 +61,22 @@ Packs/NamespacedUnderPackageName:
   Exclude:
     - lib/example.rb
 ```
+
+## Other Utilities
+`rubocop-packs` also has some API that help you use rubocop in a pack-based context.
+
+### `RuboCop::Packs.auto_generate_rubocop_todo(packs: ParsePackwerk.all)`
+This API will auto-generate a `packs/some_pack/.rubocop_todo.yml`. This allows a pack to own its own exception list. Note that you need to configure `rubocop-packs` with an allow list of cops that can live in per-pack `.rubocop_todo.yml` files:
+```
+# `config/rubocop_packs.rb`
+RuboCop::Packs.configure do |config|
+  # For example:
+  config.permitted_pack_level_cops = ['Packs/NamespaceConvention']
+end
+```
+
+There is a supporting validation to ensure these `packs/*/.rubocop_todo.yml` files only add exceptions to the allow listed set of rules. Run this validation with `RuboCop::packs.validate`, which returns an array of errors.
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/rubyatscale/rubocop-packs. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Code Of Conduct](CODE_OF_CONDUCT.MD).

data/config/default.yml

@@ -1,3 +1,5 @@
+inherit_from: ./pack_config.yml
+
 Packs/ClassMethodsAsPublicApis:
   Enabled: true
   AcceptableParentClasses:
@@ -14,3 +16,11 @@ Packs/TypedPublicApi:
 
 Packs/RequireDocumentedPublicApis:
   Enabled: true
+
+PackwerkLite/Privacy:
+  # It is recommended to use packwerk
+  Enabled: false
+
+PackwerkLite/Dependency:
+  # It is recommended to use packwerk
+  Enabled: false

data/config/pack_config.yml

@@ -0,0 +1,6 @@
+# Relevant documentation:
+#  - Inheriting config from a gem:
+#    - https://docs.rubocop.org/rubocop/configuration.html#inheriting-configuration-from-a-dependency-gem
+#  - ERB in a .rubocop.yml file
+#    - https://docs.rubocop.org/rubocop/configuration.html#pre-processing
+<%= RuboCop::Packs.pack_based_rubocop_todos %>

data/lib/rubocop/cop/packs/namespace_convention/desired_zeitwerk_api.rb

@@ -6,6 +6,8 @@ module RuboCop
       class NamespaceConvention < Base
         #
         # This is a private class that represents API that we would prefer to be available somehow in Zeitwerk.
+        # However, the boundaries between systems (packwerk/zeitwerk, rubocop/zeitwerk) are poor in this class, so
+        # that would need to be separated prior to proposing any API changes in zeitwerk.
         #
         class DesiredZeitwerkApi
           extend T::Sig

data/lib/rubocop/cop/packs/require_documented_public_apis.rb

@@ -4,22 +4,21 @@ module RuboCop
   module Cop
     module Packs
       # This cop helps ensure that each pack has a documented public API
+      # The following examples assume this basic setup.
       #
       # @example
       #
       #   # bad
       #   # packs/foo/app/public/foo.rb
       #   class Foo
-      #     sig { void }
-      #     def bar
+      #     def bar; end
       #   end
       #
       #   # packs/foo/app/public/foo.rb
       #   class Foo
       #     # This is a documentation comment.
       #     # It can live below or below a sorbet type signature.
-      #     sig { void }
-      #     def bar
+      #     def bar; end
       #   end
       #
       class RequireDocumentedPublicApis < Style::DocumentationMethod

data/lib/rubocop/cop/packs/typed_public_api.rb

@@ -33,6 +33,13 @@ module RuboCop
         # We can apply this same pattern if we want to use other cops in the context of package protections and prevent clashing.
         #
         extend T::Sig
+
+        sig { params(processed_source: T.untyped).void }
+        def investigate(processed_source)
+          return unless processed_source.path.include?('app/public')
+
+          super
+        end
       end
     end
   end

data/lib/rubocop/cop/packwerk_lite/constant_resolver.rb

@@ -0,0 +1,84 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      #
+      # This is a private class that represents API that we would prefer to be available somehow in Zeitwerk.
+      # However, the boundaries between systems (packwerk/zeitwerk, rubocop/zeitwerk) are poor in this class, so
+      # that would need to be separated prior to proposing any API changes in zeitwerk.
+      #
+      class ConstantResolver
+        extend T::Sig
+
+        class ConstantReference < T::Struct
+          extend T::Sig
+
+          const :constant_name, String
+          const :global_namespace, String
+          const :source_package, ParsePackwerk::Package
+          const :constant_definition_location, Pathname
+          const :referencing_file, Pathname
+
+          sig { returns(ParsePackwerk::Package) }
+          def referencing_package
+            ParsePackwerk.package_from_path(referencing_file)
+          end
+
+          sig { returns(T::Boolean) }
+          def public_api?
+            # ParsePackwerk::Package should have a method to take in a path and determine if the file is public.
+            # For now we put it here and only support the public folder (and not specific private constants).
+            constant_definition_location.to_s.include?('/public/')
+          end
+
+          sig { params(node: RuboCop::AST::ConstNode, processed_source: RuboCop::AST::ProcessedSource).returns(T.nilable(ConstantReference)) }
+          def self.resolve(node, processed_source)
+            constant_name = node.const_name
+            namespaces = constant_name.split('::')
+            global_namespace = namespaces.first
+
+            expected_containing_pack_last_name = global_namespace.underscore
+
+            # We don't use ParsePackwerk.find(...) here because we want to look for nested packs, and this pack could be a child pack in a nested pack too.
+            # In the future, we might want `find` to be able to take a glob or a regex to look for packs with a specific name structure.
+            expected_containing_pack = ParsePackwerk.all.find { |p| p.name.include?("/#{expected_containing_pack_last_name}") }
+            return if expected_containing_pack.nil?
+
+            if namespaces.count == 1
+              found_files = expected_containing_pack.directory.glob("app/*/#{expected_containing_pack_last_name}.rb")
+            else
+              expected_location_in_pack = namespaces[1..].map(&:underscore).join('/')
+              found_files = expected_containing_pack.directory.glob("app/*/#{expected_containing_pack_last_name}/#{expected_location_in_pack}.rb")
+            end
+
+            # Because of how Zietwerk works, we know two things:
+            # 1) Since namespaces map one to one with files, Zeitwerk does not permit multiple files to define the same fully-qualified class/module.
+            # (Note it does permit multiple files to open up portions of other namespaces)
+            # 2) If a file *could* define a fully qualified constant, then it *must* define that constant!
+            #
+            # Therefore when we've found possible files, we can sanity check there is only one,
+            # and then assume the found pack defines the constant!
+            raise if found_files.count > 1
+
+            expected_pack_contains_constant = found_files.any?
+
+            return if !expected_pack_contains_constant
+
+            found_file = found_files.first
+
+            ConstantReference.new(
+              constant_name: constant_name,
+              global_namespace: global_namespace,
+              source_package: expected_containing_pack,
+              constant_definition_location: T.must(found_file),
+              referencing_file: Pathname.new(processed_source.path).relative_path_from(Pathname.pwd)
+            )
+          end
+        end
+      end
+
+      private_constant :ConstantResolver
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/dependency_checker.rb

@@ -0,0 +1,77 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      # This cop helps ensure that packs are depending on packs explicitly.
+      #
+      # @example
+      #
+      #   # bad
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Bar
+      #     end
+      #   end
+      #
+      #   # packs/foo/package.yml
+      #   # enforces_dependencies: true
+      #   # enforces_privacy: false
+      #   # dependencies:
+      #   #   - packs/baz
+      #
+      #   # good
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Bar
+      #     end
+      #   end
+      #
+      #   # packs/foo/package.yml
+      #   # enforces_dependencies: true
+      #   # enforces_privacy: false
+      #   # dependencies:
+      #   #   - packs/baz
+      #   #   - packs/bar
+      #
+      class Dependency < Base
+        extend T::Sig
+
+        sig { returns(T::Boolean) }
+        def support_autocorrect?
+          false
+        end
+
+        sig { params(node: RuboCop::AST::ConstNode).void }
+        def on_const(node)
+          return if Private.partial_const_reference?(node)
+
+          constant_reference = ConstantResolver::ConstantReference.resolve(node, processed_source)
+          return if constant_reference.nil?
+          return if constant_reference.referencing_package.name == constant_reference.source_package.name
+
+          # These are cases that don't work yet!!
+          # I'll need to look into this more. It's related to inflections but not sure how yet!
+          return if constant_reference.constant_name.include?('PncApi')
+
+          is_new_violation = [
+            !constant_reference.referencing_package.dependencies.include?(constant_reference.source_package.name),
+            constant_reference.referencing_package.enforces_dependencies?,
+            !Private.violation_in_deprecated_references_yml?(constant_reference, type: 'dependency')
+          ].all?
+
+          if is_new_violation
+            add_offense(
+              node.source_range,
+              message: format(
+                'Dependency violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/privacy_checker.rb

@@ -0,0 +1,78 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      # This cop helps ensure that packs are using public API of other systems
+      # The following examples assume this basic setup.
+      #
+      # @example
+      #   # packs/bar/app/public/bar.rb
+      #   class Bar
+      #     def my_public_api; end
+      #   end
+      #
+      #   # packs/bar/app/services/private.rb
+      #   class Private
+      #     def my_private_api; end
+      #   end
+      #
+      #   # packs/bar/package.yml
+      #   # enforces_dependencies: false
+      #   # enforces_privacy: true
+      #
+      #   # bad
+      #   # packs/foo/app/services/foo.rb
+      #   class Foo
+      #     def bar
+      #       Private.my_private_api
+      #     end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/services/foo.rb
+      #   class Bar
+      #     def bar
+      #       Bar.my_public_api
+      #     end
+      #   end
+      #
+      class Privacy < Base
+        extend T::Sig
+
+        sig { returns(T::Boolean) }
+        def support_autocorrect?
+          false
+        end
+
+        sig { params(node: RuboCop::AST::ConstNode).void }
+        def on_const(node)
+          # See https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/lint/constant_resolution.rb source code as an example
+          return if Private.partial_const_reference?(node)
+
+          constant_reference = ConstantResolver::ConstantReference.resolve(node, processed_source)
+
+          # If we can't determine a constant reference, we can just early return. This could be beacuse the constant is defined
+          # in a gem OR because it's not abiding by the namespace convention we've established.
+          return if constant_reference.nil?
+          return if constant_reference.referencing_package.name == constant_reference.source_package.name
+
+          is_new_violation = [
+            !constant_reference.public_api?,
+            constant_reference.source_package.enforces_privacy?,
+            !Private.violation_in_deprecated_references_yml?(constant_reference)
+          ].all?
+
+          if is_new_violation
+            add_offense(
+              node.source_range,
+              message: format(
+                'Privacy violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
+              )
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/packwerk_lite/private.rb

@@ -0,0 +1,38 @@
+# typed: strict
+
+module RuboCop
+  module Cop
+    module PackwerkLite
+      module Private
+        extend T::Sig
+
+        sig { params(node: RuboCop::AST::ConstNode).returns(T::Boolean) }
+        def self.partial_const_reference?(node)
+          # This is a bit whacky, but if I have a reference in the code like this: Foo::Bar::Baz.any_method, `on_const` will be called three times:
+          # One with `Foo`, one with `Foo::Bar`, and one with `Foo::Bar::Baz`.
+          # As far as I can tell, there is no way to direct Rubocop to only look at the full constant name.
+          # In order to ensure we're only operating on fully constant names, I check the "right sibling" of the `node`, which is the portion of the AST
+          # immediately following the node.
+          # If that right sibling is `nil` OR it's a lowercase string, we assume that it's the full constant.
+          # If the right sibling is a non-nil capitalized string, we assume it's a part of the constant, because by convention, constants
+          # start with capital letters and methods start with lowercase letters.
+          # RegularRateOfPay::Types::HourlyEarningWithDate
+          right_sibling = node.right_sibling
+          return false if right_sibling.nil?
+
+          right_sibling.to_s[0].capitalize == right_sibling.to_s[0]
+        end
+
+        sig { params(constant_reference: ConstantResolver::ConstantReference, type: String).returns(T::Boolean) }
+        def self.violation_in_deprecated_references_yml?(constant_reference, type: 'privacy')
+          existing_violations = ParsePackwerk::DeprecatedReferences.for(constant_reference.referencing_package).violations
+          existing_violations.any? do |v|
+            v.class_name == "::#{constant_reference.constant_name}" && (type == 'privacy' ? v.privacy? : v.dependency?)
+          end
+        end
+      end
+
+      private_constant :Private
+    end
+  end
+end

data/lib/rubocop/packs/private/configuration.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RuboCop
+  module Packs
+    module Private
+      class Configuration
+        extend T::Sig
+
+        sig { returns(T::Array[String]) }
+        attr_accessor :permitted_pack_level_cops
+
+        sig { void }
+        def initialize
+          @permitted_pack_level_cops = T.let([], T::Array[String])
+        end
+
+        sig { void }
+        def bust_cache!
+          @permitted_pack_level_cops = []
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/packs/private.rb

@@ -1,9 +1,39 @@
 # typed: strict
 # frozen_string_literal: true
 
+require 'rubocop/packs/private/configuration'
+
 module RuboCop
   module Packs
     module Private
+      extend T::Sig
+
+      sig { void }
+      def self.bust_cache!
+        @rubocop_todo_ymls = nil
+        @loaded_client_configuration = nil
+      end
+
+      sig { void }
+      def self.load_client_configuration
+        @loaded_client_configuration ||= T.let(false, T.nilable(T::Boolean))
+        return if @loaded_client_configuration
+
+        @loaded_client_configuration = true
+        client_configuration = Pathname.pwd.join('config/rubocop_packs.rb')
+        require client_configuration.to_s if client_configuration.exist?
+      end
+
+      sig { returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+      def self.rubocop_todo_ymls
+        @rubocop_todo_ymls = T.let(@rubocop_todo_ymls, T.nilable(T::Array[T::Hash[T.untyped, T.untyped]]))
+        @rubocop_todo_ymls ||= begin
+          todo_files = Pathname.glob('**/.rubocop_todo.yml')
+          todo_files.map do |todo_file|
+            YAML.load_file(todo_file)
+          end
+        end
+      end
     end
 
     private_constant :Private

data/lib/rubocop/packs.rb

@@ -14,5 +14,155 @@ module RuboCop
     CONFIG         = T.let(YAML.safe_load(CONFIG_DEFAULT.read).freeze, T.untyped)
 
     private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+
+    #
+    # Ideally, this is API that is available to us via `rubocop` itself.
+    # That is: the ability to preserve the location of `.rubocop_todo.yml` files and associate
+    # exclusions with the closest ancestor `.rubocop_todo.yml`
+    #
+    sig { params(packs: T::Array[ParsePackwerk::Package]).void }
+    def self.auto_generate_rubocop_todo(packs:)
+      pack_arguments = packs.map(&:name).join(' ')
+      cop_arguments = config.permitted_pack_level_cops.join(',')
+      command = "bundle exec rubocop #{pack_arguments} --only=#{cop_arguments} --format=json"
+      puts "Executing: #{command}"
+      json = JSON.parse(`#{command}`)
+      new_rubocop_todo_exclusions = {}
+      json['files'].each do |file_hash|
+        filepath = file_hash['path']
+        pack = ParsePackwerk.package_from_path(filepath)
+        next if pack.name == ParsePackwerk::ROOT_PACKAGE_NAME
+
+        file_hash['offenses'].each do |offense_hash|
+          cop_name = offense_hash['cop_name']
+          next unless config.permitted_pack_level_cops.include?(cop_name)
+
+          new_rubocop_todo_exclusions[pack.name] ||= {}
+          new_rubocop_todo_exclusions[pack.name][filepath] ||= []
+          new_rubocop_todo_exclusions[pack.name][filepath] << cop_name
+        end
+      end
+
+      new_rubocop_todo_exclusions.each do |pack_name, file_hash|
+        pack = T.must(ParsePackwerk.find(pack_name))
+        rubocop_todo_yml = pack.directory.join('.rubocop_todo.yml')
+        if rubocop_todo_yml.exist?
+          rubocop_todo = YAML.load_file(rubocop_todo_yml)
+        else
+          rubocop_todo = {}
+        end
+        file_hash.each do |file, failing_cops|
+          failing_cops.each do |failing_cop|
+            rubocop_todo[failing_cop] ||= { 'Exclude' => [] }
+            rubocop_todo[failing_cop]['Exclude'] << file
+          end
+        end
+
+        next if rubocop_todo.empty?
+
+        rubocop_todo_yml.write(YAML.dump(rubocop_todo))
+      end
+    end
+
+    sig { params(root_pathname: String).returns(String) }
+    # It would be great if rubocop (upstream) could take in a glob for `inherit_from`, which
+    # would allow us to delete this method and this additional complexity.
+    def self.pack_based_rubocop_todos(root_pathname: Bundler.root)
+      rubocop_todos = {}
+      # We do this because when the ERB is evaluated Dir.pwd is at the directory containing the YML.
+      # Ideally rubocop wouldn't change the PWD before invoking this method.
+      Dir.chdir(root_pathname) do
+        ParsePackwerk.all.each do |package|
+          next if package.name == ParsePackwerk::ROOT_PACKAGE_NAME
+
+          rubocop_todo = package.directory.join('.rubocop_todo.yml')
+          next unless rubocop_todo.exist?
+
+          loaded_rubocop_todo = YAML.load_file(rubocop_todo)
+          loaded_rubocop_todo.each do |protection_key, key_config|
+            rubocop_todos[protection_key] ||= { 'Exclude' => [] }
+            rubocop_todos[protection_key]['Exclude'] += key_config['Exclude']
+          end
+        end
+      end
+
+      YAML.dump(rubocop_todos)
+    end
+
+    sig { void }
+    def self.bust_cache!
+      config.bust_cache!
+      Private.bust_cache!
+    end
+
+    sig { params(blk: T.proc.params(arg0: Private::Configuration).void).void }
+    def self.configure(&blk)
+      yield(config)
+    end
+
+    sig { returns(Private::Configuration) }
+    def self.config
+      Private.load_client_configuration
+      @config = T.let(@config, T.nilable(Private::Configuration))
+      @config ||= Private::Configuration.new
+    end
+
+    sig { params(rule: String).returns(T::Set[String]) }
+    def self.exclude_for_rule(rule)
+      excludes = T.let(Set.new, T::Set[String])
+
+      Private.rubocop_todo_ymls.each do |todo_yml|
+        next if !todo_yml
+
+        config = todo_yml[rule]
+        next if config.nil?
+
+        exclude_list = config['Exclude']
+        next if exclude_list.nil?
+
+        excludes += exclude_list
+      end
+
+      excludes
+    end
+
+    sig { returns(T::Array[String]) }
+    def self.validate
+      errors = []
+      ParsePackwerk.all.each do |package|
+        next if package.name == ParsePackwerk::ROOT_PACKAGE_NAME
+
+        rubocop_todo = package.directory.join('.rubocop_todo.yml')
+        next unless rubocop_todo.exist?
+
+        loaded_rubocop_todo = YAML.load_file(rubocop_todo)
+        loaded_rubocop_todo.each_key do |key|
+          if !config.permitted_pack_level_cops.include?(key)
+            errors << <<~ERROR_MESSAGE
+              #{rubocop_todo} contains invalid configuration for #{key}.
+              Please ensure the only configuration is for package protection exclusions, which are one of the following cops: #{config.permitted_pack_level_cops.inspect}"
+              For ignoring other cops, please instead modify the top-level .rubocop_todo.yml file.
+            ERROR_MESSAGE
+          elsif loaded_rubocop_todo[key].keys != ['Exclude']
+            errors << <<~ERROR_MESSAGE
+              #{rubocop_todo} contains invalid configuration for #{key}.
+              Please ensure the only configuration for #{key} is `Exclude`
+            ERROR_MESSAGE
+          else
+            loaded_rubocop_todo[key]['Exclude'].each do |filepath|
+              next unless ParsePackwerk.package_from_path(filepath).name != package.name
+
+              errors << <<~ERROR_MESSAGE
+                #{rubocop_todo} contains invalid configuration for #{key}.
+                #{filepath} does not belong to #{package.name}. Please ensure you only add exclusions
+                for files within this pack.
+              ERROR_MESSAGE
+            end
+          end
+        end
+      end
+
+      errors
+    end
   end
 end

data/lib/rubocop/packwerk_lite.rb

@@ -0,0 +1,15 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'rubocop/cop/packwerk_lite/private'
+require 'rubocop/cop/packwerk_lite/constant_resolver'
+require 'rubocop/cop/packwerk_lite/privacy_checker'
+require 'rubocop/cop/packwerk_lite/dependency_checker'
+
+module RuboCop
+  # See docs/packwerk_lite.md
+  module PackwerkLite
+    class Error < StandardError; end
+    extend T::Sig
+  end
+end

data/lib/rubocop-packs.rb

@@ -6,6 +6,7 @@ require 'parse_packwerk'
 
 require_relative 'rubocop/packs'
 require_relative 'rubocop/packs/inject'
+require_relative 'rubocop/packwerk_lite'
 
 require 'rubocop/cop/packs/namespace_convention'
 require 'rubocop/cop/packs/typed_public_api'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-packs
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.0.12
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-07 00:00:00.000000000 Z
+date: 2022-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -187,15 +187,22 @@ extra_rdoc_files: []
 files:
 - README.md
 - config/default.yml
+- config/pack_config.yml
 - lib/rubocop-packs.rb
 - lib/rubocop/cop/packs/class_methods_as_public_apis.rb
 - lib/rubocop/cop/packs/namespace_convention.rb
 - lib/rubocop/cop/packs/namespace_convention/desired_zeitwerk_api.rb
 - lib/rubocop/cop/packs/require_documented_public_apis.rb
 - lib/rubocop/cop/packs/typed_public_api.rb
+- lib/rubocop/cop/packwerk_lite/constant_resolver.rb
+- lib/rubocop/cop/packwerk_lite/dependency_checker.rb
+- lib/rubocop/cop/packwerk_lite/privacy_checker.rb
+- lib/rubocop/cop/packwerk_lite/private.rb
 - lib/rubocop/packs.rb
 - lib/rubocop/packs/inject.rb
 - lib/rubocop/packs/private.rb
+- lib/rubocop/packs/private/configuration.rb
+- lib/rubocop/packwerk_lite.rb
 - sorbet/config
 - sorbet/rbi/gems/activesupport@7.0.4.rbi
 - sorbet/rbi/gems/ast@2.4.2.rbi
@@ -259,7 +266,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: Fill this out!