visualize_packwerk 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e1857563c4bf2c40025fbf771b4e5d0ee3d3b1a7623015097274ae1198a6ab6
-  data.tar.gz: b917ec146a3e97aec95effe57ae0ab5905ec5456549a6bbd2d65dd5ed6a6fd2d
+  metadata.gz: dbd24c4c7be488fb37b173c00512196884dafe06e1788bbfb9fd3161988f395b
+  data.tar.gz: 0c4da79eef14eba7759074636a556d03f2e74a1b964b485bba0d7e090c83471b
 SHA512:
-  metadata.gz: d4f389a11294cbd70ba330e6f7888e03f1dd1666aa80f15214d40914f3fdfe6d711103fc02b364ee5caf4c2344c7bdc343e3be32693bf99801decf94b031860e
-  data.tar.gz: 2a500bb635dc10ac6785d648be7cc1e8dd8396d2dfd48a45059ee1ba924a8fe26d1b782bebeea1c43f94721eca08ef0ada4c41f1918d484f3eaa3380c6d11d1c
+  metadata.gz: 38855ce47c28b248a67de636f9e530e850425b5b7823ccc3bd1f13bde14c6bacd5aa32b68b68f54244325b6c75f8050586b36e98d5c5f0f2e90265728594f854
+  data.tar.gz: 68c24d06b1f0c9ae4d109806d0459b38a58e6d6827a07bc745fe6dafaddf17a15c359f80a9b21e495c386eac8ceeba5e8e66d40162d3ee572544c01b5fc35e10

data/lib/visualize_packwerk/package_graph.rb

@@ -27,7 +27,7 @@ module VisualizePackwerk
         # We would also need to ignore it when parsing PackageNodes.
         # next if p.name == ParsePackwerk::ROOT_PACKAGE_NAME
         owner = CodeOwnership.for_package(p)
-        violations_by_package = PackageProtections::ProtectedPackage.from(p).violations.group_by(&:to_package_name).transform_values(&:count)
+        violations_by_package = p.violations.group_by(&:to_package_name).transform_values(&:count)
 
         package_nodes << PackageNode.new(
           name: p.name,

data/lib/visualize_packwerk/package_relationships.rb

@@ -6,25 +6,6 @@ module VisualizePackwerk
 
     OUTPUT_FILENAME = T.let('packwerk.png'.freeze, String)
 
-    sig { void }
-    def initialize
-      @colors_by_team = T.let({}, T::Hash[String, String])
-      @remaining_colors = T.let(
-        [
-          # Found using https://htmlcolorcodes.com/color-picker/
-          '#77EE77', # green
-          '#DFEE77', # yellow
-          '#77EEE6', # teal
-          '#EEC077', # orange
-          '#EE77BF', # pink
-          '#EE6F6F', # red
-          '#ED6EDE', # magenta
-          '#8E8CFE', # blue
-          '#EEA877', # red-orange
-        ], T::Array[String]
-      )
-    end
-
     sig { params(teams: T::Array[CodeTeams::Team]).void }
     def create_package_graph_for_teams!(teams)
       packages = ParsePackwerk.all.select do |package|
@@ -38,27 +19,27 @@ module VisualizePackwerk
     def create_team_graph!(teams, show_all_teams: false)
       package_graph = PackageGraph.construct
       team_graph = TeamGraph.from_package_graph(package_graph)
-      highlighted_node_names = teams.map(&:name)
+      node_names = teams.map(&:name)
 
-      draw_graph!(team_graph, highlighted_node_names, show_all_nodes: show_all_teams)
+      draw_graph!(team_graph, node_names, show_all_nodes: show_all_teams)
     end
 
-    sig { params(packages: T::Array[ParsePackwerk::Package], show_all_packs: T::Boolean).void }
-    def create_package_graph!(packages, show_all_packs: false)
+    sig { params(packages: T::Array[ParsePackwerk::Package]).void }
+    def create_package_graph!(packages)
       graph = PackageGraph.construct
-      highlighted_node_names = packages.map(&:name)
-      draw_graph!(graph, highlighted_node_names, show_all_nodes: show_all_packs)
+      node_names = packages.map(&:name)
+      draw_graph!(graph, node_names)
     end
 
     sig { params(packages: T::Array[ParsePackwerk::Package], show_all_nodes: T::Boolean).void }
     def create_graph!(packages, show_all_nodes: false)
       graph = PackageGraph.construct
-      highlighted_node_names = packages.map(&:name)
-      draw_graph!(graph, highlighted_node_names, show_all_nodes: show_all_nodes)
+      node_names = packages.map(&:name)
+      draw_graph!(graph, node_names, show_all_nodes: show_all_nodes)
     end
 
-    sig { params(graph: GraphInterface, highlighted_node_names: T::Array[String], show_all_nodes: T::Boolean).void }
-    def draw_graph!(graph, highlighted_node_names, show_all_nodes: false)
+    sig { params(graph: GraphInterface, node_names: T::Array[String], show_all_nodes: T::Boolean).void }
+    def draw_graph!(graph, node_names, show_all_nodes: false)
       # SFDP looks better than dot in some cases, but less good in other cases.
       # If your visualization looks bad, change the layout to other_layout!
       # https://graphviz.org/docs/layouts/
@@ -69,13 +50,10 @@ module VisualizePackwerk
       # Create graph nodes
       graphviz_nodes = T.let({}, T::Hash[String, GraphViz::Node])
 
-      nodes_to_draw = graph.nodes
+      nodes_to_draw = graph.nodes.select{|n| node_names.include?(n.name) }
 
       nodes_to_draw.each do |node|
-        next unless highlighted_node_names.any? { |highlighted_node_name| node.depends_on?(highlighted_node_name) } || highlighted_node_names.include?(node.name)
-
-        highlight_node = highlighted_node_names.include?(node.name) && !show_all_nodes
-        graphviz_nodes[node.name] = add_node(node, graphviz_graph, highlight_node)
+        graphviz_nodes[node.name] = add_node(node, graphviz_graph)
       end
 
       max_edge_width = 10
@@ -83,7 +61,7 @@ module VisualizePackwerk
       # Draw all edges
       nodes_to_draw.each do |node|
         node.dependencies.each do |to_node|
-          next unless highlighted_node_names.include?(to_node)
+          next unless node_names.include?(to_node)
 
           graphviz_graph.add_edges(
             graphviz_nodes[node.name],
@@ -93,7 +71,7 @@ module VisualizePackwerk
         end
 
         node.violations_by_node_name.each do |to_node_name, violation_count|
-          next unless highlighted_node_names.include?(to_node_name)
+          next unless node_names.include?(to_node_name)
 
           edge_width = [
             [(violation_count / 5).to_i, 1].max, # rubocop:disable Lint/NumberConversion
@@ -114,44 +92,20 @@ module VisualizePackwerk
       puts 'Finished!'
     end
 
-    sig { params(node: NodeInterface, graph: GraphViz, highlight_node: T::Boolean).returns(GraphViz::Node) }
-    def add_node(node, graph, highlight_node)
-      default_node_options = {
+    sig { params(node: NodeInterface, graph: GraphViz).returns(GraphViz::Node) }
+    def add_node(node, graph)
+      node_options = {
         fontsize: 26.0,
-        fontcolor: 'white',
-        fillcolor: 'black',
+        fontcolor: 'black',
+        fillcolor: 'white',
         color: 'black',
         height: 1.0,
         style: 'filled, rounded',
         shape: 'box',
       }
 
-      node_options = if highlight_node
-        default_node_options.merge(
-          fillcolor: highlight_by_group(node),
-          color: highlight_by_group(node),
-          fontcolor: 'black'
-        )
-      else
-        default_node_options
-      end
-
       graph.add_nodes(node.name, **node_options)
     end
-
-    sig { params(node: NodeInterface).returns(String) }
-    def highlight_by_group(node)
-      highlighted_package_color = @colors_by_team[node.group_name]
-      if !highlighted_package_color
-        highlighted_package_color = @remaining_colors.first
-        raise 'Can only color nodes a max of 5 unique colors for now' if highlighted_package_color.nil?
-
-        @remaining_colors.delete(highlighted_package_color)
-        @colors_by_team[node.group_name] = highlighted_package_color
-      end
-
-      highlighted_package_color
-    end
   end
 
   private_constant :PackageRelationships

data/lib/visualize_packwerk/tasks/visualize_packwerk.rake

@@ -27,7 +27,7 @@ module VisualizePackwerk
             end
           end
 
-          PackageRelationships.new.create_package_graph!(packages, show_all_packs: show_all_packs)
+          PackageRelationships.new.create_package_graph!(packages)
         end
 
         # This creates the array of symbols that are needed to declare an argument to a rake task

data/lib/visualize_packwerk.rb

@@ -4,7 +4,6 @@ module VisualizePackwerk
   require 'visualize_packwerk/railtie' if defined?(Rails)
   require 'parse_packwerk'
   require 'code_ownership'
-  require 'package_protections'
   require 'graphviz'
 
   require 'visualize_packwerk/node_interface'

data/sorbet/config

@@ -1,2 +1,3 @@
 --dir
 .
+--ignore=/vendor/bundle

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

@@ -4,20 +4,30 @@
 # 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-0.14.0/lib/parse_packwerk/constants.rb:3
 module ParsePackwerk
   class << self
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:28
     sig { returns(T::Array[::ParsePackwerk::Package]) }
     def all; end
 
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:112
+    sig { void }
+    def bust_cache!; end
+
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:33
     sig { params(name: ::String).returns(T.nilable(::ParsePackwerk::Package)) }
     def find(name); end
 
-    sig { params(file_path: T.any(::Pathname, ::String)).returns(T.nilable(::ParsePackwerk::Package)) }
+    # source://parse_packwerk-0.14.0/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-0.14.0/lib/parse_packwerk.rb:54
     sig { params(package: ::ParsePackwerk::Package).void }
     def write_package_yml!(package); end
 
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:38
     sig { returns(::ParsePackwerk::Configuration) }
     def yml; end
 
@@ -25,94 +35,148 @@ module ParsePackwerk
 
     # 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-0.14.0/lib/parse_packwerk.rb:100
     sig { returns(T::Hash[::String, ::ParsePackwerk::Package]) }
     def packages_by_name; end
   end
 end
 
+# source://parse_packwerk-0.14.0/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-0.14.0/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-0.14.0/lib/parse_packwerk/configuration.rb:11
     sig { returns(::ParsePackwerk::Configuration) }
     def fetch; end
 
+    # source://sorbet-runtime-0.5.10323/lib/types/struct.rb:13
     def inherited(s); end
 
+    # source://parse_packwerk-0.14.0/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-0.14.0/lib/parse_packwerk/constants.rb:20
 ParsePackwerk::DEFAULT_EXCLUDE_GLOBS = T.let(T.unsafe(nil), Array)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:21
 ParsePackwerk::DEFAULT_PACKAGE_PATHS = T.let(T.unsafe(nil), Array)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:22
+ParsePackwerk::DEFAULT_PUBLIC_PATH = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:12
 ParsePackwerk::DEPENDENCIES = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:7
 ParsePackwerk::DEPRECATED_REFERENCES_YML_NAME = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/deprecated_references.rb:4
 class ParsePackwerk::DeprecatedReferences < ::T::Struct
   const :pathname, ::Pathname
   const :violations, T::Array[::ParsePackwerk::Violation]
 
   class << self
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk/deprecated_references.rb:11
     sig { params(package: ::ParsePackwerk::Package).returns(::ParsePackwerk::DeprecatedReferences) }
     def for(package); end
 
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk/deprecated_references.rb:17
     sig { params(pathname: ::Pathname).returns(::ParsePackwerk::DeprecatedReferences) }
     def from(pathname); end
 
+    # source://sorbet-runtime-0.5.10323/lib/types/struct.rb:13
     def inherited(s); end
   end
 end
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:8
 ParsePackwerk::ENFORCE_DEPENDENCIES = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:9
 ParsePackwerk::ENFORCE_PRIVACY = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:11
 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-0.14.0/lib/parse_packwerk/constants.rb:16
 ParsePackwerk::MetadataYmlType = T.type_alias { T::Hash[T.untyped, T.untyped] }
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:14
 class ParsePackwerk::MissingConfiguration < ::StandardError
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk.rb:18
   sig { params(packwerk_file_name: ::Pathname).void }
   def initialize(packwerk_file_name); end
 end
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:5
 ParsePackwerk::PACKAGE_YML_NAME = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:6
 ParsePackwerk::PACKWERK_YML_NAME = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/constants.rb:10
+ParsePackwerk::PUBLIC_PATH = T.let(T.unsafe(nil), String)
+
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:4
 class ParsePackwerk::Package < ::T::Struct
   const :dependencies, T::Array[::String]
   const :enforce_dependencies, T::Boolean
   const :enforce_privacy, T::Boolean
   const :metadata, T::Hash[T.untyped, T.untyped]
   const :name, ::String
+  const :public_path, ::String, default: T.unsafe(nil)
 
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:35
   sig { returns(::Pathname) }
   def directory; end
 
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:45
   sig { returns(T::Boolean) }
   def enforces_dependencies?; end
 
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:50
   sig { returns(T::Boolean) }
   def enforces_privacy?; end
 
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:40
+  sig { returns(::Pathname) }
+  def public_directory; end
+
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:55
+  sig { returns(T::Array[::ParsePackwerk::Violation]) }
+  def violations; end
+
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:30
   sig { returns(::Pathname) }
   def yml; end
 
   class << self
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk/package.rb:15
     sig { params(pathname: ::Pathname).returns(::ParsePackwerk::Package) }
     def from(pathname); end
 
+    # source://sorbet-runtime-0.5.10323/lib/types/struct.rb:13
     def inherited(s); end
   end
 end
 
+# source://parse_packwerk-0.14.0/lib/parse_packwerk/package_set.rb:8
 class ParsePackwerk::PackageSet
   class << self
+    # source://parse_packwerk-0.14.0/lib/parse_packwerk/package_set.rb:12
     sig do
       params(
         package_pathspec: T::Array[::String],
@@ -123,26 +187,32 @@ class ParsePackwerk::PackageSet
 
     private
 
+    # source://parse_packwerk-0.14.0/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-0.14.0/lib/parse_packwerk/constants.rb:4
 ParsePackwerk::ROOT_PACKAGE_NAME = T.let(T.unsafe(nil), String)
 
+# source://parse_packwerk-0.14.0/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-0.14.0/lib/parse_packwerk/violation.rb:13
   sig { returns(T::Boolean) }
   def dependency?; end
 
+  # source://parse_packwerk-0.14.0/lib/parse_packwerk/violation.rb:18
   sig { returns(T::Boolean) }
   def privacy?; end
 
   class << self
+    # source://sorbet-runtime-0.5.10323/lib/types/struct.rb:13
     def inherited(s); end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: visualize_packwerk
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Gusto Engineers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-12 00:00:00.000000000 Z
+date: 2022-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -38,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: package_protections
-  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: code_ownership
   requirement: !ruby/object:Gem::Requirement
@@ -180,9 +166,8 @@ files:
 - sorbet/rbi/gems/json@2.6.2.rbi
 - sorbet/rbi/gems/method_source@1.0.0.rbi
 - sorbet/rbi/gems/minitest@5.16.2.rbi
-- sorbet/rbi/gems/package_protections@1.3.0.rbi
 - sorbet/rbi/gems/parallel@1.22.1.rbi
-- sorbet/rbi/gems/parse_packwerk@0.11.0.rbi
+- sorbet/rbi/gems/parse_packwerk@0.14.0.rbi
 - sorbet/rbi/gems/parser@3.1.2.0.rbi
 - sorbet/rbi/gems/pry@0.14.1.rbi
 - sorbet/rbi/gems/rainbow@3.1.1.rbi
@@ -234,7 +219,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: A gem to visualize connections in a Rails app that uses Packwerk

data/sorbet/rbi/gems/package_protections@1.3.0.rbi

@@ -1,654 +0,0 @@
-# typed: true
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `package_protections` gem.
-# Please instead update this file by running `bin/tapioca gem package_protections`.
-
-# Welcome to PackageProtections!
-# See https://github.com/rubyatscale/package_protections#readme for more info
-#
-# This file is a reference for the available API to `package_protections`, but all implementation details are private
-# (which is why we delegate to `Private` for the actual implementation).
-module PackageProtections
-  class << self
-    sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-    def all; end
-
-    sig { void }
-    def bust_cache!; end
-
-    # @yield [Private.config]
-    sig { params(blk: T.proc.params(arg0: ::PackageProtections::Private::Configuration).void).void }
-    def configure(&blk); end
-
-    # This returns an array of a `Offense` which is how we represent the outcome of attempting to protect one or more packages,
-    # each of which is configured with different violation behaviors for each protection.
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-    end
-    def get_offenses(packages:, new_violations:); end
-
-    sig do
-      params(
-        package_names: T::Array[::String],
-        all_packages: T::Array[::ParsePackwerk::Package]
-      ).returns(T::Array[::ParsePackwerk::Package])
-    end
-    def packages_for_names(package_names, all_packages); end
-
-    # Do not use this method -- it's meant to be used by Rubocop cops to get directory-specific
-    # parameters without needing to have directory-specific .rubocop.yml files.
-    sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
-    def private_cop_config(identifier); end
-
-    # Why do we use Bundler.root here?
-    # The reason is that this function is evaluated in `.client_rubocop.yml`, so when rubocop evaluates the
-    # YML and parses the ERB, the working directory is inside this gem. We need to make sure it's at the root of the
-    # application so that we can find all of the packwerk packages.
-    # We use Bundler.root to get the root because:
-    # A) We expect it to be reliable
-    # B) We expect the client to be running bundle exec rubocop, which is typically done at the root, and also means
-    # the client already has this dependency.
-    sig { params(root_pathname: ::Pathname).returns(::String) }
-    def rubocop_yml(root_pathname: T.unsafe(nil)); end
-
-    # PackageProtections.set_defaults! sets any unset protections to their default enforcement
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        protection_identifiers: T::Array[::String],
-        verbose: T::Boolean
-      ).void
-    end
-    def set_defaults!(packages, protection_identifiers: T.unsafe(nil), verbose: T.unsafe(nil)); end
-
-    # This is a fast way to get a protection given an identifier
-    sig { params(identifier: ::String).returns(::PackageProtections::ProtectionInterface) }
-    def with_identifier(identifier); end
-  end
-end
-
-PackageProtections::EXPECTED_PACK_DIRECTORIES = T.let(T.unsafe(nil), Array)
-
-# A protection identifier is just a string that identifies the name of the protection within a `package.yml`
-PackageProtections::Identifier = T.type_alias { ::String }
-
-# This is currently the only handled exception that `PackageProtections` will throw.
-class PackageProtections::IncorrectPublicApiUsageError < ::StandardError; end
-
-class PackageProtections::Offense < ::T::Struct
-  const :file, ::String
-  const :message, ::String
-  const :package, ::ParsePackwerk::Package
-  const :violation_type, ::String
-
-  sig { returns(::String) }
-  def package_name; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-PackageProtections::PROTECTIONS_TODO_YML = T.let(T.unsafe(nil), String)
-
-# Perhaps this should be in ParsePackwerk. For now, this is here to help us break down violations per file.
-# This is analogous to `Packwerk::ReferenceOffense`
-class PackageProtections::PerFileViolation < ::T::Struct
-  const :class_name, ::String
-  const :constant_source_package, ::String
-  const :filepath, ::String
-  const :reference_source_package, ::ParsePackwerk::Package
-  const :type, ::String
-
-  sig { returns(T::Boolean) }
-  def dependency?; end
-
-  sig { returns(T::Boolean) }
-  def privacy?; end
-
-  class << self
-    sig do
-      params(
-        violation: ::ParsePackwerk::Violation,
-        reference_source_package: ::ParsePackwerk::Package
-      ).returns(T::Array[::PackageProtections::PerFileViolation])
-    end
-    def from(violation, reference_source_package); end
-
-    def inherited(s); end
-  end
-end
-
-# This module cannot be accessed by clients of `PackageProtections` -- only within the `PackageProtections` module itself.
-# All implementation details are in here to keep the main `PackageProtections` module easily scannable and to keep the private things private.
-module PackageProtections::Private
-  class << self
-    sig { returns(T::Array[::PackageProtections::ProtectedPackage]) }
-    def all_protected_packages; end
-
-    sig { void }
-    def bust_cache!; end
-
-    sig { returns(::PackageProtections::Private::Configuration) }
-    def config; end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-    end
-    def get_offenses(packages:, new_violations:); end
-
-    sig { params(name: ::String).returns(::PackageProtections::ProtectedPackage) }
-    def get_package_with_name(name); end
-
-    sig do
-      params(
-        package_names: T::Array[::String],
-        all_packages: T::Array[::ParsePackwerk::Package]
-      ).returns(T::Array[::ParsePackwerk::Package])
-    end
-    def packages_for_names(package_names, all_packages); end
-
-    sig { params(identifier: ::String).returns(T::Hash[T.untyped, T.untyped]) }
-    def private_cop_config(identifier); end
-
-    sig { params(root_pathname: ::Pathname).returns(::String) }
-    def rubocop_yml(root_pathname:); end
-
-    sig do
-      params(
-        packages: T::Array[::ParsePackwerk::Package],
-        protection_identifiers: T::Array[::String],
-        verbose: T::Boolean
-      ).void
-    end
-    def set_defaults!(packages, protection_identifiers:, verbose:); end
-  end
-end
-
-class PackageProtections::Private::ColorizedString
-  sig { params(original_string: ::String, color: ::PackageProtections::Private::ColorizedString::Color).void }
-  def initialize(original_string, color = T.unsafe(nil)); end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def blue; end
-
-  sig { returns(::String) }
-  def colorized_to_s; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def green; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def light_blue; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def pink; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def red; end
-
-  sig { returns(::String) }
-  def to_s; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def white; end
-
-  sig { returns(::PackageProtections::Private::ColorizedString) }
-  def yellow; end
-
-  private
-
-  sig { returns(::Integer) }
-  def color_code; end
-
-  sig do
-    params(
-      color: ::PackageProtections::Private::ColorizedString::Color
-    ).returns(::PackageProtections::Private::ColorizedString)
-  end
-  def colorize(color); end
-end
-
-class PackageProtections::Private::ColorizedString::Color < ::T::Enum
-  enums do
-    Black = new
-    Red = new
-    Green = new
-    Yellow = new
-    Blue = new
-    Pink = new
-    LightBlue = new
-    White = new
-  end
-end
-
-class PackageProtections::Private::Configuration
-  sig { void }
-  def initialize; end
-
-  sig { void }
-  def bust_cache!; end
-
-  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-  def default_protections; end
-
-  sig { returns(T::Array[::PackageProtections::ProtectionInterface]) }
-  def protections; end
-
-  sig { params(protections: T::Array[::PackageProtections::ProtectionInterface]).void }
-  def protections=(protections); end
-end
-
-class PackageProtections::Private::IncomingPrivacyProtection
-  include ::PackageProtections::ProtectionInterface
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::IncomingPrivacyProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::Private::MetadataModifiers
-  class << self
-    sig do
-      params(
-        package: ::ParsePackwerk::Package,
-        protection_identifier: ::String,
-        violation_behavior: ::PackageProtections::ViolationBehavior
-      ).returns(::ParsePackwerk::Package)
-    end
-    def package_with_modified_protection(package, protection_identifier, violation_behavior); end
-  end
-end
-
-class PackageProtections::Private::OutgoingDependencyProtection
-  include ::PackageProtections::ProtectionInterface
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::OutgoingDependencyProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::Private::Output
-  class << self
-    sig { params(str: ::String).void }
-    def p(str); end
-
-    sig { params(str: ::PackageProtections::Private::ColorizedString, colorized: T::Boolean).void }
-    def p_colorized(str, colorized:); end
-  end
-end
-
-class PackageProtections::Private::VisibilityProtection
-  include ::PackageProtections::ProtectionInterface
-
-  # By default, this protection does not show up when creating a new package, and its default behavior is FailNever
-  # A package that uses this protection is not considered strictly better -- in general, we want to design packages that
-  # are consumable by all packages. Therefore, a package that is consumable by all packages is the happy path.
-  #
-  # If a user wants to turn on package visibility, they must do it explicitly.
-  sig { returns(::PackageProtections::ViolationBehavior) }
-  def default_behavior; end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  sig { override.returns(::String) }
-  def humanized_protection_description; end
-
-  sig { override.returns(::String) }
-  def humanized_protection_name; end
-
-  sig { override.returns(::String) }
-  def identifier; end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_any(per_file_violation); end
-
-  sig { params(per_file_violation: ::PackageProtections::PerFileViolation).returns(::String) }
-  def message_for_fail_on_new(per_file_violation); end
-end
-
-PackageProtections::Private::VisibilityProtection::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-class PackageProtections::ProtectedPackage < ::T::Struct
-  const :deprecated_references, ::ParsePackwerk::DeprecatedReferences
-  const :original_package, ::ParsePackwerk::Package
-  const :protections, T::Hash[::String, ::PackageProtections::ViolationBehavior]
-
-  sig { returns(T::Array[::String]) }
-  def dependencies; end
-
-  sig { returns(T::Hash[T.untyped, T.untyped]) }
-  def metadata; end
-
-  sig { returns(::String) }
-  def name; end
-
-  sig { params(key: ::String).returns(::PackageProtections::ViolationBehavior) }
-  def violation_behavior_for(key); end
-
-  sig { returns(T::Array[::ParsePackwerk::Violation]) }
-  def violations; end
-
-  sig { returns(T::Set[::String]) }
-  def visible_to; end
-
-  sig { returns(::Pathname) }
-  def yml; end
-
-  class << self
-    sig { params(original_package: ::ParsePackwerk::Package).returns(::PackageProtections::ProtectedPackage) }
-    def from(original_package); end
-
-    sig do
-      params(
-        protection: ::PackageProtections::ProtectionInterface,
-        metadata: T::Hash[T.untyped, T.untyped],
-        package: ::ParsePackwerk::Package
-      ).returns(::PackageProtections::ViolationBehavior)
-    end
-    def get_violation_behavior(protection, metadata, package); end
-
-    def inherited(s); end
-  end
-end
-
-# @abstract Subclasses must implement the `abstract` methods below.
-module PackageProtections::ProtectionInterface
-  requires_ancestor { Kernel }
-
-  abstract!
-
-  sig { returns(::PackageProtections::ViolationBehavior) }
-  def default_behavior; end
-
-  sig do
-    params(
-      protected_packages: T::Array[::PackageProtections::ProtectedPackage],
-      new_violations: T::Array[::PackageProtections::PerFileViolation]
-    ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses(protected_packages, new_violations); end
-
-  # @abstract
-  sig do
-    abstract
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  # @abstract
-  sig do
-    abstract
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  # @abstract
-  sig { abstract.returns(::String) }
-  def humanized_protection_description; end
-
-  # @abstract
-  sig { abstract.returns(::String) }
-  def humanized_protection_name; end
-
-  # @abstract
-  sig { abstract.returns(::String) }
-  def identifier; end
-
-  sig do
-    params(
-      behavior: ::PackageProtections::ViolationBehavior,
-      package: ::ParsePackwerk::Package
-    ).returns(T::Boolean)
-  end
-  def supports_violation_behavior?(behavior, package); end
-
-  # @abstract
-  sig do
-    abstract
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-end
-
-# @abstract Subclasses must implement the `abstract` methods below.
-module PackageProtections::RubocopProtectionInterface
-  include ::PackageProtections::ProtectionInterface
-
-  abstract!
-
-  sig do
-    params(
-      packages: T::Array[::PackageProtections::ProtectedPackage]
-    ).returns(T::Array[::PackageProtections::RubocopProtectionInterface::CopConfig])
-  end
-  def cop_configs(packages); end
-
-  # Abstract Methods: These are methods that the client needs to implement
-  #
-  # @abstract
-  sig { abstract.returns(::String) }
-  def cop_name; end
-
-  # Overriddable Methods: These are methods that the client can override,
-  # but a default is provided.
-  sig { params(package: ::PackageProtections::ProtectedPackage).returns(T::Hash[T.untyped, T.untyped]) }
-  def custom_cop_config(package); end
-
-  sig do
-    override
-      .params(
-        protected_packages: T::Array[::PackageProtections::ProtectedPackage]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_existing_violations(protected_packages); end
-
-  sig do
-    override
-      .params(
-        new_violations: T::Array[::PackageProtections::PerFileViolation]
-      ).returns(T::Array[::PackageProtections::Offense])
-  end
-  def get_offenses_for_new_violations(new_violations); end
-
-  # @abstract
-  sig { abstract.returns(T::Array[::String]) }
-  def included_globs_for_pack; end
-
-  # @abstract
-  sig { abstract.params(file: ::String).returns(::String) }
-  def message_for_fail_on_any(file); end
-
-  sig do
-    override
-      .params(
-        behavior: ::PackageProtections::ViolationBehavior,
-        package: ::ParsePackwerk::Package
-      ).returns(T.nilable(::String))
-  end
-  def unmet_preconditions_for_behavior(behavior, package); end
-
-  private
-
-  sig { params(rule: ::String).returns(T::Set[::String]) }
-  def exclude_for_rule(rule); end
-
-  class << self
-    sig { void }
-    def bust_rubocop_todo_yml_cache; end
-
-    sig { returns(T.untyped) }
-    def rubocop_todo_yml; end
-  end
-end
-
-class PackageProtections::RubocopProtectionInterface::CopConfig < ::T::Struct
-  const :enabled, T::Boolean, default: T.unsafe(nil)
-  const :exclude_paths, T::Array[::String], default: T.unsafe(nil)
-  const :include_paths, T::Array[::String], default: T.unsafe(nil)
-  const :name, ::String
-
-  sig { returns(::String) }
-  def to_rubocop_yml_compatible_format; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-class PackageProtections::ViolationBehavior < ::T::Enum
-  enums do
-    FailOnAny = new
-    FailOnNew = new
-    FailNever = new
-  end
-
-  sig { returns(T::Boolean) }
-  def enabled?; end
-
-  sig { returns(T::Boolean) }
-  def fail_never?; end
-
-  sig { returns(T::Boolean) }
-  def fail_on_any?; end
-
-  sig { returns(T::Boolean) }
-  def fail_on_new?; end
-
-  class << self
-    sig { params(value: T.untyped).returns(::PackageProtections::ViolationBehavior) }
-    def from_raw_value(value); end
-  end
-end
-
-RuboCop::Cop::PackageProtections::NamespacedUnderPackageName::IDENTIFIER = T.let(T.unsafe(nil), String)
-
-# This inherits from `Sorbet::StrictSigil` and doesn't change any behavior of it.
-# The only reason we do this is so that configuration for this cop can live under a different cop namespace.
-# This prevents this cop's configuration from clashing with other configurations for the same cop.
-# A concrete example of this would be if a user is using this package protection to make sure public APIs are typed,
-# and separately the application as a whole requiring strict typing in certain parts of the application.
-#
-# To prevent problems associated with needing to manage identical configurations for the same cop, we simply call it
-# something else in the context of this protection.
-#
-# We can apply this same pattern if we want to use other cops in the context of package protections and prevent clashing.