pack_stats 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 60606e6b527c76b27deaac01ad5991ebe06ec7db76bc5fe9eb707d0cfdde9c56
-  data.tar.gz: ec768521fe361499a52bb29b59b97d23249ef9bd6a9c1bc3c543c8d46d6ccc08
+  metadata.gz: da5c8a0753cdd0e4b878fc2fb2c2732fc5ca3664b1e53dc55f9c16e3b7f43fef
+  data.tar.gz: a57f443a4572e99c7bd8c187d5b963ff9fdecebf71cf5d1339518ea3f89d5852
 SHA512:
-  metadata.gz: f33cff3e350f90dbd71cf07433df45bfc170fd9c2101e5713cae1976e034385af98fbc76eddc01ac0ed78009f6e23f2b2f43797999d1fd6e8405fbdb50c013b1
-  data.tar.gz: f04b2b9ac1e3cdf3fcdf0811a1d2a9d1b0a8b2864278ed892caf61c1676fcf762839d24f03ef0f7625895ec37287dcaf3cc034c7ab672468d9b5b1ccf18a15a6
+  metadata.gz: 5c1bed7cbd4c71fe9937b9ea9ceb47a9784b7852f3a788f0f69c240848dd1d106e5be56a0005a2f6785f5e948c3419b2c9d7094bca559112e3289fe4334ea3ed
+  data.tar.gz: 06c0b6fd7a7af65934ad6c6f346bb0fafa61874742c12f4d752b8437e5f6024c34153a079c0666004d68eac8c693fbd5354a62d2fc7d45e8bdb6615ded6d0569

data/lib/pack_stats/private/metrics/nested_packs.rb

@@ -53,7 +53,7 @@ module PackStats
           sig { returns(T::Array[ParsePackwerk::Violation]) }
           def cross_group_violations
             all_violations = members.flat_map do |member|
-              ParsePackwerk::DeprecatedReferences.for(member).violations
+              ParsePackwerk::PackageTodo.for(member).violations
             end
 
             all_violations.select do |violation|

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

@@ -12,7 +12,6 @@ module PackStats
         # Later, we might find a way we can get this directly from `packwerk`
         class PackwerkChecker < T::Struct
           const :setting, String
-          const :strict_mode, String
         end
 
         sig { params(prefix: String, packages: T::Array[ParsePackwerk::Package], package_tags: T::Array[Tag]).returns(T::Array[GaugeMetric]) }
@@ -20,22 +19,21 @@ module PackStats
           metrics = T.let([], T::Array[GaugeMetric])
 
           checkers = [
-            PackwerkChecker.new(setting: 'enforce_dependencies', strict_mode: 'enforce_dependencies_strictly'),
-            PackwerkChecker.new(setting: 'enforce_privacy', strict_mode: 'enforce_privacy_strictly')
+            PackwerkChecker.new(setting: 'enforce_dependencies'),
+            PackwerkChecker.new(setting: 'enforce_privacy')
           ]
 
           checkers.each do |checker|
             ['false', 'true', 'strict'].each do |enabled_mode|
               count_of_packages = ParsePackwerk.all.count do |package|
-                strict_mode = package.metadata[checker.strict_mode]
-                enabled = YAML.load_file(package.yml)[checker.setting]
+                checker_setting = YAML.load_file(package.yml)[checker.setting]
                 case enabled_mode
                 when 'false'
-                  !enabled
+                  !checker_setting
                 when 'true'
-                  enabled && !strict_mode
+                  checker_setting && checker_setting != 'strict'
                 when 'strict'
-                  !!strict_mode
+                  checker_setting == 'strict'
                 end
               end
 

data/sorbet/rbi/gems/ast@2.4.2.rbi

@@ -0,0 +1,584 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `bin/tapioca gem ast`.
+
+# {AST} is a library for manipulating abstract syntax trees.
+#
+# It embraces immutability; each AST node is inherently frozen at
+# creation, and updating a child node requires recreating that node
+# and its every parent, recursively.
+# This is a design choice. It does create some pressure on
+# garbage collector, but completely eliminates all concurrency
+# and aliasing problems.
+#
+# See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+# additional recommendations and design patterns.
+#
+# source://ast//lib/ast.rb#13
+module AST; end
+
+# Node is an immutable class, instances of which represent abstract
+# syntax tree nodes. It combines semantic information (i.e. anything
+# that affects the algorithmic properties of a program) with
+# meta-information (line numbers or compiler intermediates).
+#
+# Notes on inheritance
+# ====================
+#
+# The distinction between semantics and metadata is important. Complete
+# semantic information should be contained within just the {#type} and
+# {#children} of a Node instance; in other words, if an AST was to be
+# stripped of all meta-information, it should remain a valid AST which
+# could be successfully processed to yield a result with the same
+# algorithmic properties.
+#
+# Thus, Node should never be inherited in order to define methods which
+# affect or return semantic information, such as getters for `class_name`,
+# `superclass` and `body` in the case of a hypothetical `ClassNode`. The
+# correct solution is to use a generic Node with a {#type} of `:class`
+# and three children. See also {Processor} for tips on working with such
+# ASTs.
+#
+# On the other hand, Node can and should be inherited to define
+# application-specific metadata (see also {#initialize}) or customize the
+# printing format. It is expected that an application would have one or two
+# such classes and use them across the entire codebase.
+#
+# The rationale for this pattern is extensibility and maintainability.
+# Unlike static ones, dynamic languages do not require the presence of a
+# predefined, rigid structure, nor does it improve dispatch efficiency,
+# and while such a structure can certainly be defined, it does not add
+# any value but incurs a maintaining cost.
+# For example, extending the AST even with a transformation-local
+# temporary node type requires making globally visible changes to
+# the codebase.
+#
+# source://ast//lib/ast/node.rb#40
+class AST::Node
+  # Constructs a new instance of Node.
+  #
+  # The arguments `type` and `children` are converted with `to_sym` and
+  # `to_a` respectively. Additionally, the result of converting `children`
+  # is frozen. While mutating the arguments is generally considered harmful,
+  # the most common case is to pass an array literal to the constructor. If
+  # your code does not expect the argument to be frozen, use `#dup`.
+  #
+  # The `properties` hash is passed to {#assign_properties}.
+  #
+  # @return [Node] a new instance of Node
+  #
+  # source://ast//lib/ast/node.rb#72
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  # Concatenates `array` with `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#168
+  def +(array); end
+
+  # Appends `element` to `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#177
+  def <<(element); end
+
+  # Compares `self` to `other`, possibly converting with `to_ast`. Only
+  # `type` and `children` are compared; metadata is deliberately ignored.
+  #
+  # @return [Boolean]
+  #
+  # source://ast//lib/ast/node.rb#153
+  def ==(other); end
+
+  # Appends `element` to `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#177
+  def append(element); end
+
+  # Returns the children of this node.
+  # The returned value is frozen.
+  # The to_a alias is useful for decomposing nodes concisely.
+  # For example:
+  #
+  #     node = s(:gasgn, :$foo, s(:integer, 1))
+  #     var_name, value = *node
+  #     p var_name # => :$foo
+  #     p value    # => (integer 1)
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#56
+  def children; end
+
+  # Nodes are already frozen, so there is no harm in returning the
+  # current node as opposed to initializing from scratch and freezing
+  # another one.
+  #
+  # @return self
+  #
+  # source://ast//lib/ast/node.rb#115
+  def clone; end
+
+  # Concatenates `array` with `children` and returns the resulting node.
+  #
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#168
+  def concat(array); end
+
+  # Enables matching for Node, where type is the first element
+  # and the children are remaining items.
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#253
+  def deconstruct; end
+
+  # Nodes are already frozen, so there is no harm in returning the
+  # current node as opposed to initializing from scratch and freezing
+  # another one.
+  #
+  # @return self
+  #
+  # source://ast//lib/ast/node.rb#115
+  def dup; end
+
+  # Test if other object is equal to
+  #
+  # @param other [Object]
+  # @return [Boolean]
+  #
+  # source://ast//lib/ast/node.rb#85
+  def eql?(other); end
+
+  # Returns the precomputed hash value for this node
+  #
+  # @return [Fixnum]
+  #
+  # source://ast//lib/ast/node.rb#61
+  def hash; end
+
+  # Converts `self` to a s-expression ruby string.
+  # The code return will recreate the node, using the sexp module s()
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#211
+  def inspect(indent = T.unsafe(nil)); end
+
+  # Returns the children of this node.
+  # The returned value is frozen.
+  # The to_a alias is useful for decomposing nodes concisely.
+  # For example:
+  #
+  #     node = s(:gasgn, :$foo, s(:integer, 1))
+  #     var_name, value = *node
+  #     p var_name # => :$foo
+  #     p value    # => (integer 1)
+  #
+  # @return [Array]
+  #
+  # source://ast//lib/ast/node.rb#56
+  def to_a; end
+
+  # @return [AST::Node] self
+  #
+  # source://ast//lib/ast/node.rb#229
+  def to_ast; end
+
+  # Converts `self` to a pretty-printed s-expression.
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#187
+  def to_s(indent = T.unsafe(nil)); end
+
+  # Converts `self` to a pretty-printed s-expression.
+  #
+  # @param indent [Integer] Base indentation level.
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#187
+  def to_sexp(indent = T.unsafe(nil)); end
+
+  # Converts `self` to an Array where the first element is the type as a Symbol,
+  # and subsequent elements are the same representation of its children.
+  #
+  # @return [Array<Symbol, [...Array]>]
+  #
+  # source://ast//lib/ast/node.rb#237
+  def to_sexp_array; end
+
+  # Returns the type of this node.
+  #
+  # @return [Symbol]
+  #
+  # source://ast//lib/ast/node.rb#43
+  def type; end
+
+  # Returns a new instance of Node where non-nil arguments replace the
+  # corresponding fields of `self`.
+  #
+  # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield
+  # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would
+  # yield `(foo)`.
+  #
+  # If the resulting node would be identical to `self`, does nothing.
+  #
+  # @param type [Symbol, nil]
+  # @param children [Array, nil]
+  # @param properties [Hash, nil]
+  # @return [AST::Node]
+  #
+  # source://ast//lib/ast/node.rb#133
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  protected
+
+  # By default, each entry in the `properties` hash is assigned to
+  # an instance variable in this instance of Node. A subclass should define
+  # attribute readers for such variables. The values passed in the hash
+  # are not frozen or whitelisted; such behavior can also be implemented
+  # by subclassing Node and overriding this method.
+  #
+  # @return [nil]
+  #
+  # source://ast//lib/ast/node.rb#98
+  def assign_properties(properties); end
+
+  # Returns `@type` with all underscores replaced by dashes. This allows
+  # to write symbol literals without quotes in Ruby sources and yet have
+  # nicely looking s-expressions.
+  #
+  # @return [String]
+  #
+  # source://ast//lib/ast/node.rb#264
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
+end
+
+# This class includes {AST::Processor::Mixin}; however, it is
+# deprecated, since the module defines all of the behaviors that
+# the processor includes.  Any new libraries should use
+# {AST::Processor::Mixin} instead of subclassing this.
+#
+# @deprecated Use {AST::Processor::Mixin} instead.
+#
+# source://ast//lib/ast/processor.rb#8
+class AST::Processor
+  include ::AST::Processor::Mixin
+end
+
+# The processor module is a module which helps transforming one
+# AST into another.  In a nutshell, the {#process} method accepts
+# a {Node} and dispatches it to a handler corresponding to its
+# type, and returns a (possibly) updated variant of the node.
+#
+# The processor module has a set of associated design patterns.
+# They are best explained with a concrete example. Let's define a
+# simple arithmetic language and an AST format for it:
+#
+# Terminals (AST nodes which do not have other AST nodes inside):
+#
+#   * `(integer <int-literal>)`,
+#
+# Nonterminals (AST nodes with other nodes as children):
+#
+#   * `(add <node> <node>)`,
+#   * `(multiply <node> <node>)`,
+#   * `(divide <node> <node>)`,
+#   * `(negate <node>)`,
+#   * `(store <node> <string-literal>)`: stores value of `<node>`
+#     into a variable named `<string-literal>`,
+#   * `(load <string-literal>)`: loads value of a variable named
+#     `<string-literal>`,
+#   * `(each <node> ...)`: computes each of the `<node>`s and
+#     prints the result.
+#
+# All AST nodes have the same Ruby class, and therefore they don't
+# know how to traverse themselves. (A solution which dynamically
+# checks the type of children is possible, but is slow and
+# error-prone.) So, a class including the module which knows how
+# to traverse the entire tree should be defined.  Such classes
+# have a handler for each nonterminal node which recursively
+# processes children nodes:
+#
+#     require 'ast'
+#
+#     class ArithmeticsProcessor
+#       include AST::Processor::Mixin
+#       # This method traverses any binary operators such as (add)
+#       # or (multiply).
+#       def process_binary_op(node)
+#         # Children aren't decomposed automatically; it is
+#         # suggested to use Ruby multiple assignment expansion,
+#         # as it is very convenient here.
+#         left_expr, right_expr = *node
+#
+#         # AST::Node#updated won't change node type if nil is
+#         # passed as a first argument, which allows to reuse the
+#         # same handler for multiple node types using `alias'
+#         # (below).
+#         node.updated(nil, [
+#           process(left_expr),
+#           process(right_expr)
+#         ])
+#       end
+#       alias_method :on_add,      :process_binary_op
+#       alias_method :on_multiply, :process_binary_op
+#       alias_method :on_divide,   :process_binary_op
+#
+#       def on_negate(node)
+#         # It is also possible to use #process_all for more
+#         # compact code if every child is a Node.
+#         node.updated(nil, process_all(node))
+#       end
+#
+#       def on_store(node)
+#         expr, variable_name = *node
+#
+#         # Note that variable_name is not a Node and thus isn't
+#         # passed to #process.
+#         node.updated(nil, [
+#           process(expr),
+#           variable_name
+#         ])
+#       end
+#
+#       # (load) is effectively a terminal node, and so it does
+#       # not need an explicit handler, as the following is the
+#       # default behavior.  Essentially, for any nodes that don't
+#       # have a defined handler, the node remains unchanged.
+#       def on_load(node)
+#         nil
+#       end
+#
+#       def on_each(node)
+#         node.updated(nil, process_all(node))
+#       end
+#     end
+#
+# Let's test our ArithmeticsProcessor:
+#
+#     include AST::Sexp
+#     expr = s(:add, s(:integer, 2), s(:integer, 2))
+#
+#     p ArithmeticsProcessor.new.process(expr) == expr # => true
+#
+# As expected, it does not change anything at all. This isn't
+# actually very useful, so let's now define a Calculator, which
+# will compute the expression values:
+#
+#     # This Processor folds nonterminal nodes and returns an
+#     # (integer) terminal node.
+#     class ArithmeticsCalculator < ArithmeticsProcessor
+#       def compute_op(node)
+#         # First, node children are processed and then unpacked
+#         # to local variables.
+#         nodes = process_all(node)
+#
+#         if nodes.all? { |node| node.type == :integer }
+#           # If each of those nodes represents a literal, we can
+#           # fold this node!
+#           values = nodes.map { |node| node.children.first }
+#           AST::Node.new(:integer, [
+#             yield(values)
+#           ])
+#         else
+#           # Otherwise, we can just leave the current node in the
+#           # tree and only update it with processed children
+#           # nodes, which can be partially folded.
+#           node.updated(nil, nodes)
+#         end
+#       end
+#
+#       def on_add(node)
+#         compute_op(node) { |left, right| left + right }
+#       end
+#
+#       def on_multiply(node)
+#         compute_op(node) { |left, right| left * right }
+#       end
+#     end
+#
+# Let's check:
+#
+#     p ArithmeticsCalculator.new.process(expr) # => (integer 4)
+#
+# Excellent, the calculator works! Now, a careful reader could
+# notice that the ArithmeticsCalculator does not know how to
+# divide numbers. What if we pass an expression with division to
+# it?
+#
+#     expr_with_division = \
+#       s(:add,
+#         s(:integer, 1),
+#         s(:divide,
+#           s(:add, s(:integer, 8), s(:integer, 4)),
+#           s(:integer, 3))) # 1 + (8 + 4) / 3
+#
+#     folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division)
+#     p folded_expr_with_division
+#     # => (add
+#     #      (integer 1)
+#     #      (divide
+#     #        (integer 12)
+#     #        (integer 3)))
+#
+# As you can see, the expression was folded _partially_: the inner
+# `(add)` node which could be computed was folded to
+# `(integer 12)`, the `(divide)` node is left as-is because there
+# is no computing handler for it, and the root `(add)` node was
+# also left as it is because some of its children were not
+# literals.
+#
+# Note that this partial folding is only possible because the
+# _data_ format, i.e. the format in which the computed values of
+# the nodes are represented, is the same as the AST itself.
+#
+# Let's extend our ArithmeticsCalculator class further.
+#
+#     class ArithmeticsCalculator
+#       def on_divide(node)
+#         compute_op(node) { |left, right| left / right }
+#       end
+#
+#       def on_negate(node)
+#         # Note how #compute_op works regardless of the operator
+#         # arity.
+#         compute_op(node) { |value| -value }
+#       end
+#     end
+#
+# Now, let's apply our renewed ArithmeticsCalculator to a partial
+# result of previous evaluation:
+#
+#     p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5)
+#
+# Five! Excellent. This is also pretty much how CRuby 1.8 executed
+# its programs.
+#
+# Now, let's do some automated bug searching. Division by zero is
+# an error, right? So if we could detect that someone has divided
+# by zero before the program is even run, that could save some
+# debugging time.
+#
+#     class DivisionByZeroVerifier < ArithmeticsProcessor
+#       class VerificationFailure < Exception; end
+#
+#       def on_divide(node)
+#         # You need to process the children to handle nested divisions
+#         # such as:
+#         # (divide
+#         #   (integer 1)
+#         #   (divide (integer 1) (integer 0))
+#         left, right = process_all(node)
+#
+#         if right.type == :integer &&
+#            right.children.first == 0
+#           raise VerificationFailure, "Ouch! This code divides by zero."
+#         end
+#       end
+#
+#       def divides_by_zero?(ast)
+#         process(ast)
+#         false
+#       rescue VerificationFailure
+#         true
+#       end
+#     end
+#
+#     nice_expr = \
+#       s(:divide,
+#         s(:add, s(:integer, 10), s(:integer, 2)),
+#         s(:integer, 4))
+#
+#     p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr)
+#     # => false. Good.
+#
+#     bad_expr = \
+#       s(:add, s(:integer, 10),
+#         s(:divide, s(:integer, 1), s(:integer, 0)))
+#
+#     p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr)
+#     # => true. WHOOPS. DO NOT RUN THIS.
+#
+# Of course, this won't detect more complex cases... unless you
+# use some partial evaluation before! The possibilites are
+# endless. Have fun.
+#
+# source://ast//lib/ast/processor/mixin.rb#240
+module AST::Processor::Mixin
+  # Default handler. Does nothing.
+  #
+  # @param node [AST::Node]
+  # @return [AST::Node, nil]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#284
+  def handler_missing(node); end
+
+  # Dispatches `node`. If a node has type `:foo`, then a handler
+  # named `on_foo` is invoked with one argument, the `node`; if
+  # there isn't such a handler, {#handler_missing} is invoked
+  # with the same argument.
+  #
+  # If the handler returns `nil`, `node` is returned; otherwise,
+  # the return value of the handler is passed along.
+  #
+  # @param node [AST::Node, nil]
+  # @return [AST::Node, nil]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#251
+  def process(node); end
+
+  # {#process}es each node from `nodes` and returns an array of
+  # results.
+  #
+  # @param nodes [Array<AST::Node>]
+  # @return [Array<AST::Node>]
+  #
+  # source://ast//lib/ast/processor/mixin.rb#274
+  def process_all(nodes); end
+end
+
+# This simple module is very useful in the cases where one needs
+# to define deeply nested ASTs from Ruby code, for example, in
+# tests. It should be used like this:
+#
+#     describe YourLanguage::AST do
+#       include Sexp
+#
+#       it "should correctly parse expressions" do
+#         YourLanguage.parse("1 + 2 * 3").should ==
+#             s(:add,
+#               s(:integer, 1),
+#               s(:multiply,
+#                 s(:integer, 2),
+#                 s(:integer, 3)))
+#       end
+#     end
+#
+# This way the amount of boilerplate code is greatly reduced.
+#
+# source://ast//lib/ast/sexp.rb#20
+module AST::Sexp
+  # Creates a {Node} with type `type` and children `children`.
+  # Note that the resulting node is of the type AST::Node and not a
+  # subclass.
+  # This would not pose a problem with comparisons, as {Node#==}
+  # ignores metadata.
+  #
+  # source://ast//lib/ast/sexp.rb#26
+  def s(type, *children); end
+end

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

@@ -4,86 +4,120 @@
 # This is an autogenerated file for types exported from the `parse_packwerk` gem.
 # Please instead update this file by running `bin/tapioca gem parse_packwerk`.
 
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#3
 module ParsePackwerk
   class << self
+    # source://parse_packwerk//lib/parse_packwerk.rb#28
     sig { returns(T::Array[::ParsePackwerk::Package]) }
     def all; end
 
+    # source://parse_packwerk//lib/parse_packwerk.rb#112
     sig { void }
     def bust_cache!; end
 
+    # source://parse_packwerk//lib/parse_packwerk.rb#33
     sig { params(name: ::String).returns(T.nilable(::ParsePackwerk::Package)) }
     def find(name); end
 
+    # source://parse_packwerk//lib/parse_packwerk.rb#43
     sig { params(file_path: T.any(::Pathname, ::String)).returns(::ParsePackwerk::Package) }
     def package_from_path(file_path); end
 
+    # source://parse_packwerk//lib/parse_packwerk.rb#54
     sig { params(package: ::ParsePackwerk::Package).void }
     def write_package_yml!(package); end
 
+    # source://parse_packwerk//lib/parse_packwerk.rb#38
     sig { returns(::ParsePackwerk::Configuration) }
     def yml; end
 
     private
 
+    # We memoize packages_by_name for fast lookup.
+    # Since Graph is an immutable value object, we can create indexes and general caching mechanisms safely.
+    #
+    # source://parse_packwerk//lib/parse_packwerk.rb#100
     sig { returns(T::Hash[::String, ::ParsePackwerk::Package]) }
     def packages_by_name; end
   end
 end
 
+# source://parse_packwerk//lib/parse_packwerk/configuration.rb#4
 class ParsePackwerk::Configuration < ::T::Struct
   const :exclude, T::Array[::String]
   const :package_paths, T::Array[::String]
 
   class << self
+    # source://parse_packwerk//lib/parse_packwerk/configuration.rb#28
     sig { params(config_hash: T::Hash[T.untyped, T.untyped]).returns(T::Array[::String]) }
     def excludes(config_hash); end
 
+    # source://parse_packwerk//lib/parse_packwerk/configuration.rb#11
     sig { returns(::ParsePackwerk::Configuration) }
     def fetch; end
 
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
     def inherited(s); end
 
+    # source://parse_packwerk//lib/parse_packwerk/configuration.rb#40
     sig { params(config_hash: T::Hash[T.untyped, T.untyped]).returns(T::Array[::String]) }
     def package_paths(config_hash); end
   end
 end
 
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#22
 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)
 
-class ParsePackwerk::DeprecatedReferences < ::T::Struct
-  const :pathname, ::Pathname
-  const :violations, T::Array[::ParsePackwerk::Violation]
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#23
+ParsePackwerk::DEFAULT_PACKAGE_PATHS = T.let(T.unsafe(nil), Array)
 
-  class << self
-    sig { params(package: ::ParsePackwerk::Package).returns(::ParsePackwerk::DeprecatedReferences) }
-    def for(package); end
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#24
+ParsePackwerk::DEFAULT_PUBLIC_PATH = T.let(T.unsafe(nil), String)
 
-    sig { params(pathname: ::Pathname).returns(::ParsePackwerk::DeprecatedReferences) }
-    def from(pathname); end
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#14
+ParsePackwerk::DEPENDENCIES = T.let(T.unsafe(nil), String)
 
-    def inherited(s); end
-  end
-end
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#10
+ParsePackwerk::DEPENDENCY_VIOLATION_TYPE = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#8
 ParsePackwerk::ENFORCE_DEPENDENCIES = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#9
 ParsePackwerk::ENFORCE_PRIVACY = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#13
 ParsePackwerk::METADATA = T.let(T.unsafe(nil), String)
+
+# Since this metadata is unstructured YAML, it could be any type. We leave it to clients of `ParsePackwerk::Package`
+# to add types based on their known usage of metadata.
+#
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#18
 ParsePackwerk::MetadataYmlType = T.type_alias { T::Hash[T.untyped, T.untyped] }
 
+# source://parse_packwerk//lib/parse_packwerk.rb#14
 class ParsePackwerk::MissingConfiguration < ::StandardError
+  # source://parse_packwerk//lib/parse_packwerk.rb#18
   sig { params(packwerk_file_name: ::Pathname).void }
   def initialize(packwerk_file_name); end
 end
 
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#7
+ParsePackwerk::PACKAGE_TODO_YML_NAME = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#5
 ParsePackwerk::PACKAGE_YML_NAME = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#6
 ParsePackwerk::PACKWERK_YML_NAME = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#11
+ParsePackwerk::PRIVACY_VIOLATION_TYPE = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#12
 ParsePackwerk::PUBLIC_PATH = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk//lib/parse_packwerk/package.rb#4
 class ParsePackwerk::Package < ::T::Struct
   const :dependencies, T::Array[::String]
   const :enforce_dependencies, T::Boolean
@@ -92,34 +126,44 @@ class ParsePackwerk::Package < ::T::Struct
   const :name, ::String
   const :public_path, ::String, default: T.unsafe(nil)
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#35
   sig { returns(::Pathname) }
   def directory; end
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#45
   sig { returns(T::Boolean) }
   def enforces_dependencies?; end
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#50
   sig { returns(T::Boolean) }
   def enforces_privacy?; end
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#40
   sig { returns(::Pathname) }
   def public_directory; end
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#55
   sig { returns(T::Array[::ParsePackwerk::Violation]) }
   def violations; end
 
+  # source://parse_packwerk//lib/parse_packwerk/package.rb#30
   sig { returns(::Pathname) }
   def yml; end
 
   class << self
+    # source://parse_packwerk//lib/parse_packwerk/package.rb#15
     sig { params(pathname: ::Pathname).returns(::ParsePackwerk::Package) }
     def from(pathname); end
 
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
     def inherited(s); end
   end
 end
 
+# source://parse_packwerk//lib/parse_packwerk/package_set.rb#8
 class ParsePackwerk::PackageSet
   class << self
+    # source://parse_packwerk//lib/parse_packwerk/package_set.rb#12
     sig do
       params(
         package_pathspec: T::Array[::String],
@@ -130,26 +174,51 @@ class ParsePackwerk::PackageSet
 
     private
 
+    # source://parse_packwerk//lib/parse_packwerk/package_set.rb#28
     sig { params(globs: T::Array[::String], path: ::Pathname).returns(T::Boolean) }
     def exclude_path?(globs, path); end
   end
 end
 
+# source://parse_packwerk//lib/parse_packwerk/package_todo.rb#4
+class ParsePackwerk::PackageTodo < ::T::Struct
+  const :pathname, ::Pathname
+  const :violations, T::Array[::ParsePackwerk::Violation]
+
+  class << self
+    # source://parse_packwerk//lib/parse_packwerk/package_todo.rb#11
+    sig { params(package: ::ParsePackwerk::Package).returns(::ParsePackwerk::PackageTodo) }
+    def for(package); end
+
+    # source://parse_packwerk//lib/parse_packwerk/package_todo.rb#17
+    sig { params(pathname: ::Pathname).returns(::ParsePackwerk::PackageTodo) }
+    def from(pathname); end
+
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://parse_packwerk//lib/parse_packwerk/constants.rb#4
 ParsePackwerk::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk//lib/parse_packwerk/violation.rb#4
 class ParsePackwerk::Violation < ::T::Struct
   const :class_name, ::String
   const :files, T::Array[::String]
   const :to_package_name, ::String
   const :type, ::String
 
+  # source://parse_packwerk//lib/parse_packwerk/violation.rb#13
   sig { returns(T::Boolean) }
   def dependency?; end
 
+  # source://parse_packwerk//lib/parse_packwerk/violation.rb#18
   sig { returns(T::Boolean) }
   def privacy?; end
 
   class << self
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
     def inherited(s); end
   end
 end

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

@@ -0,0 +1,272 @@
+# 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`.
+
+# source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#4
+module RuboCop; end
+
+# source://rubocop-packs//lib/rubocop/cop/packwerk_lite/private.rb#4
+module RuboCop::Cop; end
+
+# source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#5
+module RuboCop::Cop::Packs; end
+
+# 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.
+#
+# source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#12
+class RuboCop::Cop::Packs::RootNamespaceIsPackName::DesiredZeitwerkApi
+  # For now, this API includes `package_for_path`
+  # If this were truly zeitwerk API, it wouldn't include any mention of packs and it would likely not need the package at all
+  # Since it could get the actual namespace without knowing anything about packs.
+  # However, we would need to pass to it the desired namespace based on the pack name for it to be able to suggest
+  # a desired filepath.
+  # Likely this means that our own cop should determine the desired namespace and pass that in
+  # and this can determine actual namespace and how to get to expected.
+  #
+  # source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#32
+  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
+
+  # source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#86
+  sig { params(pack: ::ParsePackwerk::Package).returns(::String) }
+  def get_pack_based_namespace(pack); end
+
+  private
+
+  # source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#103
+  sig { params(remaining_file_path: ::String, package_name: ::String).returns(::String) }
+  def get_actual_namespace(remaining_file_path, package_name); end
+
+  # source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#98
+  sig { params(pack: ::ParsePackwerk::Package).returns(::String) }
+  def get_package_last_name(pack); end
+
+  # source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#93
+  sig { returns(::Pathname) }
+  def root_pathname; end
+end
+
+# source://rubocop-packs//lib/rubocop/cop/packs/root_namespace_is_pack_name/desired_zeitwerk_api.rb#15
+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
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# source://rubocop-packs//lib/rubocop/cop/packwerk_lite/private.rb#5
+module RuboCop::Cop::PackwerkLite; end
+
+# 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.
+#
+# source://rubocop-packs//lib/rubocop/cop/packwerk_lite/constant_resolver.rb#11
+class RuboCop::Cop::PackwerkLite::ConstantResolver; end
+
+# source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#5
+module RuboCop::Packs
+  class << self
+    # source://rubocop-packs//lib/rubocop/packs.rb#135
+    sig { void }
+    def bust_cache!; end
+
+    # source://rubocop-packs//lib/rubocop/packs.rb#146
+    sig { returns(::RuboCop::Packs::Private::Configuration) }
+    def config; end
+
+    # @yield [config]
+    #
+    # source://rubocop-packs//lib/rubocop/packs.rb#141
+    sig { params(blk: T.proc.params(arg0: ::RuboCop::Packs::Private::Configuration).void).void }
+    def configure(&blk); end
+
+    # We can remove this function once package_protections is fully deprecated
+    #
+    # source://rubocop-packs//lib/rubocop/packs.rb#154
+    sig { params(rule: ::String).returns(T::Set[::String]) }
+    def exclude_for_rule(rule); end
+
+    # source://rubocop-packs//lib/rubocop/packs.rb#99
+    sig { params(root_pathname: ::String).returns(::String) }
+    def pack_based_rubocop_config(root_pathname: T.unsafe(nil)); end
+
+    # 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`
+    #
+    # source://rubocop-packs//lib/rubocop/packs.rb#30
+    sig { params(packs: T::Array[::ParsePackwerk::Package], files: T::Array[::String]).void }
+    def regenerate_todo(packs: T.unsafe(nil), files: T.unsafe(nil)); end
+
+    # 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`
+    #
+    # source://rubocop-packs//lib/rubocop/packs.rb#78
+    sig { params(packs: T::Array[::ParsePackwerk::Package]).void }
+    def set_default_rubocop_yml(packs:); end
+
+    # Note: when we add per-pack `.rubocop.yml` files, we'll want to add some validations here
+    # to restrict what cops are permitted to be configured in those files.
+    # We might also want further (configurable?) constraints *requiring* that the "permitted pack level cops" be specified explicitly.
+    #
+    # source://rubocop-packs//lib/rubocop/packs.rb#164
+    sig { returns(T::Array[::String]) }
+    def validate; end
+  end
+end
+
+# source://rubocop-packs//lib/rubocop/packs.rb#20
+RuboCop::Packs::CONFIG = T.let(T.unsafe(nil), Hash)
+
+# source://rubocop-packs//lib/rubocop/packs.rb#19
+RuboCop::Packs::CONFIG_DEFAULT = T.let(T.unsafe(nil), Pathname)
+
+# Because RuboCop doesn't yet support plugins, we have to monkey patch in a
+# bit of our configuration.
+#
+# source://rubocop-packs//lib/rubocop/packs/inject.rb#10
+module RuboCop::Packs::Inject
+  class << self
+    # source://rubocop-packs//lib/rubocop/packs/inject.rb#14
+    sig { void }
+    def defaults!; end
+  end
+end
+
+# source://rubocop-packs//lib/rubocop/packs.rb#16
+RuboCop::Packs::PACK_LEVEL_RUBOCOP_TODO_YML = T.let(T.unsafe(nil), String)
+
+# Pack-level rubocop and rubocop_todo YML files are named differently because they are not integrated
+# into rubocop in the standard way. For example, we could call these the standard `.rubocop.yml` and
+# `.rubocop_todo.yml`. However, this introduces a number of path relativity issues (https://docs.rubocop.org/rubocop/configuration.html#path-relativity)
+# that make this approach not possible. Therefore, for pack level rubocops, we name them in a way that mirrors packwerk `package_todo.yml` files
+# for consistency and to ensure that thes are not read by rubocop except via the ERB templating mechanism.
+#
+# source://rubocop-packs//lib/rubocop/packs.rb#15
+RuboCop::Packs::PACK_LEVEL_RUBOCOP_YML = T.let(T.unsafe(nil), String)
+
+# source://rubocop-packs//lib/rubocop/packs.rb#18
+RuboCop::Packs::PROJECT_ROOT = T.let(T.unsafe(nil), Pathname)
+
+# source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#6
+module RuboCop::Packs::Private
+  class << self
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#13
+    sig { void }
+    def bust_cache!; end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#107
+    sig { params(rule: ::String).returns(T::Set[::String]) }
+    def exclude_for_rule(rule); end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#152
+    sig { params(args: T.untyped).void }
+    def execute_rubocop(args); end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#19
+    sig { void }
+    def load_client_configuration; end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#157
+    sig do
+      params(
+        paths: T::Array[::String],
+        cop_names: T::Array[::String]
+      ).returns(T::Array[::RuboCop::Packs::Private::Offense])
+    end
+    def offenses_for(paths:, cop_names:); end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#29
+    sig { returns(T::Array[T::Hash[T.untyped, T.untyped]]) }
+    def rubocop_todo_ymls; end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#126
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_failure_mode_strict(package); end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#40
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_rubocop_todo_yml(package); end
+
+    # source://rubocop-packs//lib/rubocop/packs/private.rb#75
+    sig { params(package: ::ParsePackwerk::Package).returns(T::Array[::String]) }
+    def validate_rubocop_yml(package); end
+  end
+end
+
+# source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#7
+class RuboCop::Packs::Private::Configuration
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#20
+  sig { void }
+  def initialize; end
+
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#27
+  sig { void }
+  def bust_cache!; end
+
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#17
+  sig { returns(T::Array[::String]) }
+  def globally_permitted_namespaces; end
+
+  # @return [Array<String>]
+  #
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#17
+  def globally_permitted_namespaces=(_arg0); end
+
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#11
+  sig { returns(T::Array[::String]) }
+  def permitted_pack_level_cops; end
+
+  # @return [Array<String>]
+  #
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#11
+  def permitted_pack_level_cops=(_arg0); end
+
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#14
+  sig { returns(T::Array[::String]) }
+  def required_pack_level_cops; end
+
+  # @return [Array<String>]
+  #
+  # source://rubocop-packs//lib/rubocop/packs/private/configuration.rb#14
+  def required_pack_level_cops=(_arg0); end
+end
+
+# source://rubocop-packs//lib/rubocop/packs/private/offense.rb#6
+class RuboCop::Packs::Private::Offense < ::T::Struct
+  const :cop_name, ::String
+  const :filepath, ::String
+
+  # source://rubocop-packs//lib/rubocop/packs/private/offense.rb#13
+  sig { returns(::ParsePackwerk::Package) }
+  def pack; end
+
+  class << self
+    # source://sorbet-runtime/0.5.9924/lib/types/struct.rb#13
+    def inherited(s); end
+  end
+end
+
+# See docs/packwerk_lite.md
+#
+# source://rubocop-packs//lib/rubocop/packwerk_lite.rb#11
+module RuboCop::PackwerkLite; end
+
+# source://rubocop-packs//lib/rubocop/packwerk_lite.rb#12
+class RuboCop::PackwerkLite::Error < ::StandardError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pack_stats
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-12-12 00:00:00.000000000 Z
+date: 2022-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: code_teams
@@ -189,13 +189,14 @@ files:
 - lib/pack_stats/tag.rb
 - lib/pack_stats/tags.rb
 - sorbet/config
+- sorbet/rbi/gems/ast@2.4.2.rbi
 - sorbet/rbi/gems/code_ownership@1.28.0.rbi
 - 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/parse_packwerk@0.14.0.rbi
+- sorbet/rbi/gems/parse_packwerk@0.16.0.rbi
 - sorbet/rbi/gems/rspec@3.10.0.rbi
-- sorbet/rbi/gems/rubocop-packs@0.0.20.rbi
+- sorbet/rbi/gems/rubocop-packs@0.0.30.rbi
 - sorbet/rbi/todo.rbi
 homepage: https://github.com/rubyatscale/pack_stats
 licenses:

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

@@ -1,141 +0,0 @@
-# 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