rubocop-packs 0.0.45 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7697cef47d3e7da05b21e74efca28cbe80b3a7baeabf48675ceba6fe1e0c394f
-  data.tar.gz: 25b5b3d3d20f5d621cae515533e26ba668df308dad2c3b0cfd0fac14f4a4ffb7
+  metadata.gz: c6fb879c4fde42e92de3719345a90fd8782cfd9239ec7845869df3ef942ed8b0
+  data.tar.gz: 1c2a8ad04b824ed3f5c4a5ea69032164c60057a12a45b8d2d1985b2baaa863c1
 SHA512:
-  metadata.gz: 2660e307e4541b438d4d76a79a7a19d054564bc6aba6e33b3b438f4193efeac2498e7125d40be6eea6ba51df939388531d24e5c161f233f3cd87cca8dbf6265d
-  data.tar.gz: e44adb56e5e53f1148b3949f7c870f80a17d9613d0a3f60938b08386b2990accea3300b59d6b3753f0ce1c9e56613539288f32d6eb98fe657eb38182bd6aefb4
+  metadata.gz: 0f628b8204e0124712c8a760bc52c1f5a6b15dafe7f9fa48d6d05d9e40bc0b6e86c46f43441c535936e9182314718e27a4afc33d0a7eed33297f7a14d3317be8
+  data.tar.gz: 3d88bf6ee823725ba651add5983792096e59bd7ebe3229028edb03dbb1029002270f96a3cc64d3fa47e6963e7b2b97828f64b0583ff60ee0f1a65920971ff041

data/README.md

@@ -9,7 +9,7 @@ Just install the `rubocop-packs` gem
 ```sh
 gem install rubocop-packs
 ```
-or, if you use `Bundler`, add this line your application's `Gemfile`:
+or, if you use `Bundler`, add this line to your application's `Gemfile`:
 
 ```ruby
 gem 'rubocop-packs', require: false
@@ -24,13 +24,17 @@ You need to tell RuboCop to load the Packs extension. There are three ways to do
 Put this into your `.rubocop.yml`:
 
 ```yaml
-require:
+plugins:
   - rubocop-packs
 ```
 
 Now you can run `rubocop` and it will automatically load the RuboCop Packs cops together with the standard cops.
 
+> [!NOTE]
+> The plugin system is supported in RuboCop 1.72+. In earlier versions, use `require` instead of `plugins`.
+
 ## The Cops
+
 All cops are located under [`lib/rubocop/cop/packs`](lib/rubocop/cop/packs), and contain examples/documentation.
 
 In your `.rubocop.yml`, you may treat the Packs cops just like any other cop. For example:

data/config/default.yml

@@ -1,5 +1,7 @@
 Packs/ClassMethodsAsPublicApis:
+  Description: 'Requires public API methods (in `app/public`) to be defined as class methods, which are more easily statically analyzable and typically hold less state.'
   Enabled: false
+  VersionAdded: '0.0.2'
   AcceptableParentClasses:
     - T::Enum
     - T::Struct
@@ -8,18 +10,30 @@ Packs/ClassMethodsAsPublicApis:
   AcceptableMixins: []
 
 Packs/RootNamespaceIsPackName:
+  Description: 'Requires that each file is namespaced under its pack name, so that each pack exposes exactly one root namespace.'
   Enabled: false
+  VersionAdded: '0.0.2'
 
 Packs/TypedPublicApis:
+  Description: "Requires that each pack's public API (in `app/public`) is `typed: strict`."
   Enabled: false
+  VersionAdded: '0.0.2'
 
 Packs/DocumentedPublicApis:
+  Description: 'Requires that each public API method (in `app/public`) has a documentation comment.'
   Enabled: false
+  VersionAdded: '0.0.2'
+  AllowedMethods: []
+  RequireForNonPublicMethods: false
 
 PackwerkLite/Privacy:
+  Description: 'Detects references to the private implementation of another pack instead of its public API.'
   # It is recommended to use packwerk
   Enabled: false
+  VersionAdded: '0.0.12'
 
 PackwerkLite/Dependency:
+  Description: 'Detects references to a pack that is not listed as an explicit dependency.'
   # It is recommended to use packwerk
   Enabled: false
+  VersionAdded: '0.0.12'

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

@@ -29,19 +29,12 @@ module RuboCop
       #   end
       #
       class ClassMethodsAsPublicApis < Base
-        extend T::Sig
-
-        sig { returns(T::Boolean) }
-        def support_autocorrect?
-          false
-        end
-
-        sig { params(node: T.untyped).void }
+        #: (RuboCop::AST::DefNode node) -> void
         def on_def(node)
           # This cop only applies for ruby files in `app/public`
           return if !processed_source.file_path.include?('app/public/')
 
-          # Looked at https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/MissingSuper source code as inspiration for htis part.
+          # Looked at https://www.rubydoc.info/gems/rubocop/RuboCop/Cop/Lint/MissingSuper source code as inspiration for this part.
           class_node = node.each_ancestor(:class).first
           module_node = node.each_ancestor(:module).first
           parent_class = class_node&.parent_class || module_node&.parent
@@ -52,21 +45,19 @@ module RuboCop
           class_is_allowed_to_have_instance_methods = acceptable_parent_classes.include?(parent_class&.const_name)
           return if uses_implicit_static_methods || class_is_allowed_to_have_instance_methods
 
-          is_sorbet_interface_or_abstract_class = !module_node.nil? && module_node.descendants.any? { |d| d.is_a?(RuboCop::AST::SendNode) && (d.method_name == :interface! || d.method_name == :abstract!) }
+          is_sorbet_interface_or_abstract_class = !module_node.nil? && module_node.descendants.any? { |d| d.is_a?(RuboCop::AST::SendNode) && %i(interface! abstract!).include?(d.method_name) }
           return if is_sorbet_interface_or_abstract_class
           return if node_includes_acceptable_mixin?(class_node || module_node)
 
           add_offense(
             node.source_range,
-            message: format(
-              "Public API method must be a class method (e.g. `self.#{node.method_name}(...)`)"
-            )
+            message: "Public API method must be a class method (e.g. `self.#{node.method_name}(...)`)"
           )
         end
 
         private
 
-        sig { params(node: T.untyped).returns(T::Boolean) }
+        #: ((RuboCop::AST::ClassNode | RuboCop::AST::ModuleNode)? node) -> bool
         def node_includes_acceptable_mixin?(node)
           acceptable_mixins = cop_config['AcceptableMixins'] || []
           return false if node.nil?
@@ -74,7 +65,7 @@ module RuboCop
           node.descendants.any? do |d|
             d.is_a?(RuboCop::AST::SendNode) &&
               d.method_name == :include &&
-              d.arguments.count == 1 &&
+              d.arguments.one? &&
               d.arguments.first.is_a?(RuboCop::AST::ConstNode) &&
               acceptable_mixins.include?(d.arguments.first.const_name)
           end

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -30,32 +31,162 @@ module RuboCop
       #     def bar; end
       #   end
       #
+      #   # bad - RBS signatures and Sorbet annotations are not documentation
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     # @override
+      #     #: -> void
+      #     def bar; end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     # This is a documentation comment.
+      #     # @override
+      #     #: -> void
+      #     def bar; end
+      #   end
+      #
+      # @example RequireForNonPublicMethods: false (default)
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     private
+      #
+      #     def bar; end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     protected
+      #
+      #     def bar; end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     def self.bar; end
+      #     private_class_method :bar
+      #   end
+      #
+      #   # bad - `private` does not apply to singleton methods, so `bar` is public
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     private
+      #
+      #     def self.bar; end
+      #   end
+      #
+      # @example RequireForNonPublicMethods: true
+      #
+      #   # bad
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     private
+      #
+      #     def bar; end
+      #   end
+      #
+      #   # bad
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     protected
+      #
+      #     def bar; end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     private
+      #
+      #     # This is a documentation comment.
+      #     def bar; end
+      #   end
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     protected
+      #
+      #     # This is a documentation comment.
+      #     def bar; end
+      #   end
+      #
+      # @example AllowedMethods: ['method_missing', 'respond_to_missing?']
+      #
+      #   # good
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     def method_missing(name, *args); end
+      #
+      #     def respond_to_missing?(symbol, include_private); end
+      #   end
+      #
+      #   # bad
+      #   # packs/foo/app/public/foo.rb
+      #   class Foo
+      #     def bar; end
+      #   end
+      #
       class DocumentedPublicApis < Style::DocumentationMethod
         # This cop does two things:
         # 1) It only activates for things in the public folder
-        # 2) It allows `Style/DocumentationMethod` to work with sigs as expected.
+        # 2) It allows `Style/DocumentationMethod` to work with sigs, RBS comment signatures and Sorbet annotations as expected.
         #
         # An alternate approach would be to monkey patch the existing cop, as `rubocop-sorbet` did here:
         # https://github.com/Shopify/rubocop-sorbet/blob/6634f033611604cd76eeb73eae6d8728ec82d504/lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb
         # This monkey-patched cop could/should probably be upstreamed to `rubocop-sorbet`, and then `config/default.yml` could simply set `packs/*/app/public/**/*`
         # in the default include paths. However, that strategy has the downside of resulting in more configuration for the consumer if they only want to
         # support this for some packs.
-        extend T::Sig
 
-        sig { returns(T::Boolean) }
-        def support_autocorrect?
-          false
+        # The lines of an RBS method signature as Sorbet reads them: `#:` starts one, and `#|` continues a
+        # multi-line one. https://sorbet.org/docs/rbs-support
+        RBS_SIGNATURE = /\A#[:|]/
+
+        # The comments Sorbet reads in place of a `sig`'s modifiers, such as `# @override` for `override`,
+        # plus `@without_runtime`, which `spoom srb sigs translate` writes for `T::Sig::WithoutRuntime.sig`.
+        SORBET_METHOD_ANNOTATIONS = [
+          '@abstract',
+          '@final',
+          '@overridable',
+          '@override',
+          '@override(allow_incompatible: true)',
+          '@override(allow_incompatible: false)',
+          '@override(allow_incompatible: :visibility)',
+          '@without_runtime',
+        ].freeze
+
+        # rubocop < 1.91 checks AllowedMethods inside `#check`, which this cop
+        # overrides. Drop when the gemspec floor is rubocop >= 1.91; until then the
+        # minimum-rubocop CI job covers it. Re-alias `on_defs` so it binds to this
+        # method, not the parent's.
+        #: (RuboCop::AST::DefNode node) -> void
+        def on_def(node)
+          return if allowed_methods.include?(node.method_name)
+
+          super
         end
+        alias_method :on_defs, :on_def
 
-        sig { params(node: T.untyped).void }
+        # `node` is the enclosing send for a definition passed to `module_function` or
+        # `ruby2_keywords`, and the definition itself otherwise.
+        #: ((RuboCop::AST::DefNode | RuboCop::AST::SendNode) node) -> void
         def check(node)
           # This cop only applies for ruby files in `app/public`
           return if !processed_source.file_path.include?('app/public')
-          return if non_public?(node) && !require_for_non_public_methods?
+          return if non_public_method?(node) && !require_for_non_public_methods?
 
           left_sibling = node.left_sibling
 
-          if left_sibling == :private_class_method
+          # A `Symbol` sibling means the definition was passed to a modifier, as in
+          # `private def foo` or `private_class_method def self.foo`, so both the sig and the
+          # documentation comment sit above the enclosing send rather than above the definition.
+          if left_sibling.is_a?(Symbol)
             if node_is_sorbet_signature?(node.parent.left_sibling)
               return if documentation_comment?(node.parent.left_sibling)
             elsif documentation_comment?(node.parent)
@@ -70,10 +201,77 @@ module RuboCop
           add_offense(node)
         end
 
-        sig { params(node: T.untyped).returns(T::Boolean) }
+        # `DefNode#non_public?` treats a singleton method after a bare `private` or `protected`
+        # as non-public, but those only change the visibility of instance methods. A singleton
+        # method is non-public only when `private_class_method` wraps it or later names it.
+        #: ((RuboCop::AST::DefNode | RuboCop::AST::SendNode) node) -> bool
+        def non_public_method?(node)
+          if node.is_a?(RuboCop::AST::DefNode) && node.defs_type?
+            non_public_modifier?(node.parent) || made_private_after_definition?(node)
+          else
+            non_public?(node)
+          end
+        end
+
+        #: (RuboCop::AST::DefNode node) -> bool
+        def made_private_after_definition?(node)
+          node.right_siblings.any? do |sibling|
+            sibling.is_a?(RuboCop::AST::SendNode) &&
+              (sibling.receiver.nil? || sibling.receiver.self_type?) &&
+              sibling.method?(:private_class_method) &&
+              sibling.arguments.any? do |argument|
+                argument.is_a?(RuboCop::AST::SymbolNode) && argument.value == node.method_name
+              end
+          end
+        end
+
+        #: (top node) -> bool
         def node_is_sorbet_signature?(node)
-          # Is there a better way to check if a node is a sorbet signature? Probably!
-          !!(node && (node.source.include?('sig do') || node.source.include?('sig {')))
+          case node
+          when RuboCop::AST::Node
+            # A node's `source` is `nil` when it has no source range. That is the case for the empty
+            # `args` node of a block written without parameters, as in `Struct.new(:a) do ... end`,
+            # which is the left sibling of a method defined as the block's only statement.
+            node_source = node.source
+
+            # Is there a better way to check if a node is a sorbet signature? Probably!
+            !!(node_source && (node_source.include?('sig do') || node_source.include?('sig {')))
+          else
+            # A sibling is not necessarily an AST node. It is a `Symbol` when a method definition is
+            # passed to a modifier, such as the `:private` in `private def foo`.
+            false
+          end
+        end
+
+        # A copy of `RuboCop::Cop::DocumentationComment#documentation_comment?` with two changes. Like the
+        # original, it ignores annotation keywords (`# TODO:`) and directives (`# rubocop:disable`), and it
+        # also ignores RBS comments, which, like a `sig`, are not documentation. And it reads only the
+        # comments directly above the method: the original accepts any comment above a method once one is
+        # adjacent, which an RBS signature always is, so a section heading a blank line above would count.
+        #: (RuboCop::AST::Node node) -> bool
+        def documentation_comment?(node)
+          preceding_lines = preceding_lines(node)
+
+          return false unless preceding_comment?(node, preceding_lines.last)
+
+          adjacent_comments(preceding_lines).any? do |comment|
+            !AnnotationComment.new(comment, annotation_keywords).annotation? &&
+              !interpreter_directive_comment?(comment) &&
+              !rubocop_directive_comment?(comment) &&
+              !rbs_comment?(comment)
+          end
+        end
+
+        # The unbroken run of `comments` that ends with the last one, from the bottom up.
+        #: (Array[Parser::Source::Comment] comments) -> Array[Parser::Source::Comment]
+        def adjacent_comments(comments)
+          comments.reverse.chunk_while { |below, above| below.loc.line - above.loc.last_line == 1 }.first.to_a
+        end
+
+        #: (Parser::Source::Comment comment) -> bool
+        def rbs_comment?(comment)
+          comment.text.match?(RBS_SIGNATURE) ||
+            SORBET_METHOD_ANNOTATIONS.include?(comment.text.delete_prefix('#').strip)
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -10,13 +11,26 @@ module RuboCop
         # that would need to be separated prior to proposing any API changes in zeitwerk.
         #
         class DesiredZeitwerkApi
-          extend T::Sig
+          class NamespaceContext
+            #: String
+            attr_reader :current_namespace
 
-          class NamespaceContext < T::Struct
-            const :current_namespace, String
-            const :current_fully_qualified_constant, String
-            const :expected_namespace, String
-            const :expected_filepath, String
+            #: String
+            attr_reader :current_fully_qualified_constant
+
+            #: String
+            attr_reader :expected_namespace
+
+            #: String
+            attr_reader :expected_filepath
+
+            #: (current_namespace: String, current_fully_qualified_constant: String, expected_namespace: String, expected_filepath: String) -> void
+            def initialize(current_namespace:, current_fully_qualified_constant:, expected_namespace:, expected_filepath:)
+              @current_namespace = current_namespace
+              @current_fully_qualified_constant = current_fully_qualified_constant
+              @expected_namespace = expected_namespace
+              @expected_filepath = expected_filepath
+            end
           end
 
           #
@@ -28,7 +42,7 @@ module RuboCop
           # 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.
           #
-          sig { params(relative_filename: String, package_for_path: ::Packs::Pack).returns(T.nilable(NamespaceContext)) }
+          #: (String relative_filename, ::Packs::Pack package_for_path) -> NamespaceContext?
           def for_file(relative_filename, package_for_path)
             package_name = package_for_path.name
 
@@ -48,26 +62,29 @@ module RuboCop
             # Therefore, for our implementation, we substitute out the non-namespace producing portions of the filename to count the number of namespaces.
             # Note this will *not work* properly in applications that have different assumptions about autoloading.
 
-            path_without_package_base = relative_filename.gsub(%r{#{package_name}/app/}, '')
+            path_without_package_base = relative_filename.gsub(%r(#{package_name}/app/), '')
             if path_without_package_base.include?('/concerns/')
               autoload_folder_name = path_without_package_base.split('/').first(2).join('/')
             else
-              autoload_folder_name = path_without_package_base.split('/').first
+              autoload_folder_name = path_without_package_base.split('/').fetch(0)
             end
 
-            remaining_file_path = path_without_package_base.gsub(%r{\A#{autoload_folder_name}/}, '')
+            remaining_file_path = path_without_package_base.gsub(%r(\A#{autoload_folder_name}/), '')
             actual_namespace = get_actual_namespace(remaining_file_path, package_name)
 
-            if relative_filename.include?('app/')
-              app_or_lib = 'app'
-            elsif relative_filename.include?('lib/')
-              app_or_lib = 'lib'
-            end
+            app_or_lib =
+              if relative_filename.include?('app/')
+                'app'
+              elsif relative_filename.include?('lib/')
+                'lib'
+              else
+                raise ArgumentError, "#{relative_filename} is in neither app/ nor lib/"
+              end
 
             absolute_desired_path = root_pathname.join(
               package_name,
-              T.must(app_or_lib),
-              T.must(autoload_folder_name),
+              app_or_lib,
+              autoload_folder_name,
               package_for_path.last_name,
               remaining_file_path
             )
@@ -75,26 +92,26 @@ module RuboCop
             relative_desired_path = absolute_desired_path.relative_path_from(root_pathname)
 
             NamespaceContext.new(
-              current_namespace: T.must(actual_namespace.split('::').first),
+              current_namespace: actual_namespace.split('::').fetch(0),
               current_fully_qualified_constant: actual_namespace,
               expected_namespace: get_pack_based_namespace(package_for_path),
               expected_filepath: relative_desired_path.to_s
             )
           end
 
-          sig { params(pack: ::Packs::Pack).returns(String) }
+          #: (::Packs::Pack pack) -> String
           def get_pack_based_namespace(pack)
             pack.last_name.camelize
           end
 
           private
 
-          sig { returns(Pathname) }
+          #: -> Pathname
           def root_pathname
             Pathname.pwd
           end
 
-          sig { params(remaining_file_path: String, package_name: String).returns(String) }
+          #: (String remaining_file_path, String package_name) -> String
           def get_actual_namespace(remaining_file_path, package_name)
             # If the remaining file path is a ruby file (not a directory), then it establishes a global namespace
             # Otherwise, per Zeitwerk's conventions as listed above, its a directory that establishes another global namespace

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 # For String#camelize
 require 'active_support/core_ext/string/inflections'
@@ -24,11 +25,9 @@ module RuboCop
       #   class Foo::Blah::Bar; end
       #
       class RootNamespaceIsPackName < Base
-        extend T::Sig
-
         include RangeHelp
 
-        sig { void }
+        #: -> void
         def on_new_investigation
           absolute_filepath = Pathname.new(processed_source.file_path)
           relative_filepath = absolute_filepath.relative_path_from(Pathname.pwd)
@@ -44,12 +43,16 @@ module RuboCop
           return if package_for_path.nil?
 
           namespace_context = desired_zeitwerk_api.for_file(relative_filename, package_for_path)
+          # :nocov: defensive: for_file always returns a context for the `app/` paths that reach here
           return if namespace_context.nil?
+          # :nocov:
 
-          allowed_global_namespaces = Set.new([
-                                                namespace_context.expected_namespace,
-                                                *RuboCop::Packs.config.globally_permitted_namespaces
-                                              ])
+          allowed_global_namespaces = Set.new(
+            [
+              namespace_context.expected_namespace,
+              *RuboCop::Packs.config.globally_permitted_namespaces,
+            ]
+          )
 
           package_name = package_for_path.name
           actual_namespace = namespace_context.current_namespace
@@ -63,29 +66,25 @@ module RuboCop
             add_offense(
               source_range(processed_source.buffer, 1, 0),
               message: format(
-                'Based on the filepath, this file defines `%<current_fully_qualified_constant>s`, but it should be namespaced as `%<expected_namespace>s::%<current_fully_qualified_constant>s` with path `%<expected_path>s`.',
-                package_name: package_name,
-                expected_namespace: expected_namespace,
+                'Based on the filepath, this file defines `%{current_fully_qualified_constant}`, but it should be namespaced as `%{expected_namespace}::%{current_fully_qualified_constant}` with path `%{expected_path}`.',
+                package_name:,
+                expected_namespace:,
                 expected_path: relative_desired_path,
-                current_fully_qualified_constant: current_fully_qualified_constant
+                current_fully_qualified_constant:
               )
             )
           end
         end
 
-        # In the future, we'd love this to support auto-correct.
-        # Perhaps by automatically renamespacing the file and changing its location?
-        sig { returns(T::Boolean) }
-        def support_autocorrect?
-          false
-        end
+        # In the future, we'd love this to support auto-correct,
+        # perhaps by automatically renamespacing the file and changing its location.
+        # That would mean extending `AutoCorrector` and implementing the correction.
 
         private
 
-        sig { returns(DesiredZeitwerkApi) }
+        #: -> DesiredZeitwerkApi
         def desired_zeitwerk_api
-          @desired_zeitwerk_api ||= T.let(nil, T.nilable(DesiredZeitwerkApi))
-          @desired_zeitwerk_api ||= DesiredZeitwerkApi.new
+          @desired_zeitwerk_api ||= DesiredZeitwerkApi.new #: DesiredZeitwerkApi?
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 require 'rubocop-sorbet'
 
@@ -32,9 +33,8 @@ 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 { void }
+        #: -> void
         def on_new_investigation
           return unless processed_source.path.include?('app/public')
 

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

@@ -1,4 +1,8 @@
 # typed: strict
+# frozen_string_literal: true
+
+# For String#underscore
+require 'active_support/core_ext/string/inflections'
 
 module RuboCop
   module Cop
@@ -9,31 +13,45 @@ module RuboCop
       # that would need to be separated prior to proposing any API changes in zeitwerk.
       #
       class ConstantResolver
-        extend T::Sig
+        class ConstantReference
+          #: String
+          attr_reader :constant_name
+
+          #: String
+          attr_reader :global_namespace
+
+          #: ParsePackwerk::Package
+          attr_reader :source_package
 
-        class ConstantReference < T::Struct
-          extend T::Sig
+          #: Pathname
+          attr_reader :constant_definition_location
 
-          const :constant_name, String
-          const :global_namespace, String
-          const :source_package, ParsePackwerk::Package
-          const :constant_definition_location, Pathname
-          const :referencing_file, Pathname
+          #: Pathname
+          attr_reader :referencing_file
+
+          #: (constant_name: String, global_namespace: String, source_package: ParsePackwerk::Package, constant_definition_location: Pathname, referencing_file: Pathname) -> void
+          def initialize(constant_name:, global_namespace:, source_package:, constant_definition_location:, referencing_file:)
+            @constant_name = constant_name
+            @global_namespace = global_namespace
+            @source_package = source_package
+            @constant_definition_location = constant_definition_location
+            @referencing_file = referencing_file
+          end
 
-          sig { returns(ParsePackwerk::Package) }
+          #: -> ParsePackwerk::Package
           def referencing_package
             ParsePackwerk.package_from_path(referencing_file)
           end
 
-          sig { returns(T::Boolean) }
+          #: -> bool
           def public_api?
             # PackwerkExtensions 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).
-            # However if we declare that dependency we may want to extract this into `rubocop-packwerk_lite` or something liek that!
+            # For now, we put it here and only support the public folder (and not specific private constants).
+            # However, if we declare that dependency we may want to extract this into `rubocop-packwerk_lite` or something like that!
             constant_definition_location.to_s.include?('/public/')
           end
 
-          sig { params(node: RuboCop::AST::ConstNode, processed_source: RuboCop::AST::ProcessedSource).returns(T.nilable(ConstantReference)) }
+          #: (RuboCop::AST::ConstNode node, RuboCop::AST::ProcessedSource processed_source) -> ConstantReference?
           def self.resolve(node, processed_source)
             constant_name = node.const_name
             namespaces = constant_name.split('::')
@@ -46,33 +64,35 @@ module RuboCop
             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
+            if namespaces.one?
               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:
+            # Because of how Zeitwerk 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!
+            # :nocov: defensive invariant: Zeitwerk guarantees a constant maps to at most one file
             raise if found_files.count > 1
+            # :nocov:
 
             expected_pack_contains_constant = found_files.any?
 
             return if !expected_pack_contains_constant
 
-            found_file = found_files.first
+            found_file = found_files.fetch(0)
 
             ConstantReference.new(
-              constant_name: constant_name,
-              global_namespace: global_namespace,
+              constant_name:,
+              global_namespace:,
               source_package: expected_containing_pack,
-              constant_definition_location: T.must(found_file),
+              constant_definition_location: found_file,
               referencing_file: Pathname.new(processed_source.path).relative_path_from(Pathname.pwd)
             )
           end

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -37,14 +38,7 @@ module RuboCop
       #   #   - packs/bar
       #
       class Dependency < Base
-        extend T::Sig
-
-        sig { returns(T::Boolean) }
-        def support_autocorrect?
-          false
-        end
-
-        sig { params(node: RuboCop::AST::ConstNode).void }
+        #: (RuboCop::AST::ConstNode node) -> void
         def on_const(node)
           return if Private.partial_const_reference?(node)
 
@@ -59,15 +53,13 @@ module RuboCop
           is_new_violation = [
             !constant_reference.referencing_package.dependencies.include?(constant_reference.source_package.name),
             constant_reference.referencing_package.enforces_dependencies?,
-            !Private.violation_in_package_todo_yml?(constant_reference, type: 'dependency')
+            !Private.violation_in_package_todo_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'
-              )
+              message: 'Dependency violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
             )
           end
         end

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

@@ -1,9 +1,10 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module PackwerkLite
-      # This cop helps ensure that packs are using public API of other systems
+      # This cop helps ensure that packs are using the public API of other systems
       # The following examples assume this basic setup.
       #
       # @example
@@ -38,21 +39,14 @@ module RuboCop
       #   end
       #
       class Privacy < Base
-        extend T::Sig
-
-        sig { returns(T::Boolean) }
-        def support_autocorrect?
-          false
-        end
-
-        sig { params(node: RuboCop::AST::ConstNode).void }
+        #: (RuboCop::AST::ConstNode node) -> 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
+          # If we can't determine a constant reference, we can just early return. This could be because 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
@@ -60,15 +54,13 @@ module RuboCop
           is_new_violation = [
             !constant_reference.public_api?,
             constant_reference.source_package.enforces_privacy?,
-            !Private.violation_in_package_todo_yml?(constant_reference)
+            !Private.violation_in_package_todo_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'
-              )
+              message: 'Privacy violation detected. See https://github.com/Shopify/packwerk/blob/main/RESOLVING_VIOLATIONS.md for help'
             )
           end
         end

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

@@ -1,12 +1,11 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module PackwerkLite
       module Private
-        extend T::Sig
-
-        sig { params(node: RuboCop::AST::ConstNode).returns(T::Boolean) }
+        #: (RuboCop::AST::ConstNode node) -> bool
         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`.
@@ -23,7 +22,7 @@ module RuboCop
           right_sibling.to_s[0].capitalize == right_sibling.to_s[0]
         end
 
-        sig { params(constant_reference: ConstantResolver::ConstantReference, type: String).returns(T::Boolean) }
+        #: (ConstantResolver::ConstantReference constant_reference, ?type: String) -> bool
         def self.violation_in_package_todo_yml?(constant_reference, type: 'privacy')
           existing_violations = ParsePackwerk::PackageTodo.for(constant_reference.referencing_package).violations
           existing_violations.any? do |v|

data/lib/rubocop/packs/plugin.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'lint_roller'
+
+module RuboCop
+  module Packs
+    # A plugin that integrates rubocop-packs with RuboCop's plugin system.
+    class Plugin < LintRoller::Plugin
+      #: -> LintRoller::About
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-packs',
+          version: VERSION,
+          homepage: 'https://github.com/rubyatscale/rubocop-packs',
+          description: 'A collection of Rubocop rules for gradually modularizing a ruby codebase'
+        )
+      end
+
+      #: (LintRoller::Context context) -> bool
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      #: (LintRoller::Context _context) -> LintRoller::Rules
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../config/default.yml')
+        )
+      end
+    end
+  end
+end

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

@@ -5,17 +5,15 @@ module RuboCop
   module Packs
     module Private
       class Configuration
-        extend T::Sig
-
-        sig { returns(T::Array[String]) }
+        #: Array[String]
         attr_accessor :globally_permitted_namespaces
 
-        sig { void }
+        #: -> void
         def initialize
-          @globally_permitted_namespaces = T.let([], T::Array[String])
+          @globally_permitted_namespaces = [] #: Array[String]
         end
 
-        sig { void }
+        #: -> void
         def bust_cache!
           @globally_permitted_namespaces = []
         end

data/lib/rubocop/packs/private.rb

@@ -2,21 +2,18 @@
 # frozen_string_literal: true
 
 require 'rubocop/packs/private/configuration'
-require 'rubocop/packs/private/offense'
 
 module RuboCop
   module Packs
     module Private
-      extend T::Sig
-
-      sig { void }
+      #: -> void
       def self.bust_cache!
         @loaded_client_configuration = nil
       end
 
-      sig { void }
+      #: -> void
       def self.load_client_configuration
-        @loaded_client_configuration ||= T.let(false, T.nilable(T::Boolean))
+        @loaded_client_configuration ||= false #: bool?
         return if @loaded_client_configuration
 
         @loaded_client_configuration = true

data/lib/rubocop/packs/version.rb

@@ -0,0 +1,8 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RuboCop
+  module Packs
+    VERSION = '0.1.1'
+  end
+end

data/lib/rubocop/packs.rb

@@ -5,28 +5,21 @@ require 'rubocop/packs/private'
 
 module RuboCop
   module Packs
-    extend T::Sig
-
-    PROJECT_ROOT   = T.let(Pathname.new(__dir__).parent.parent.expand_path.freeze, Pathname)
-    CONFIG_DEFAULT = T.let(PROJECT_ROOT.join('config', 'default.yml').freeze, Pathname)
-
-    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
-
-    sig { void }
+    #: -> void
     def self.bust_cache!
       config.bust_cache!
       Private.bust_cache!
     end
 
-    sig { params(blk: T.proc.params(arg0: Private::Configuration).void).void }
+    #: { (Private::Configuration arg0) -> void } -> void
     def self.configure(&blk)
       yield(config)
     end
 
-    sig { returns(Private::Configuration) }
+    #: -> Private::Configuration
     def self.config
       Private.load_client_configuration
-      @config ||= T.let(Private::Configuration.new, T.nilable(Private::Configuration))
+      @config ||= Private::Configuration.new #: Private::Configuration?
     end
   end
 end

data/lib/rubocop/packwerk_lite.rb

@@ -11,6 +11,5 @@ module RuboCop
   # See docs/packwerk_lite.md
   module PackwerkLite
     class Error < StandardError; end
-    extend T::Sig
   end
 end

data/lib/rubocop-packs.rb

@@ -5,12 +5,11 @@ require 'rubocop'
 require 'packs-specification'
 
 require_relative 'rubocop/packs'
-require_relative 'rubocop/packs/inject'
+require_relative 'rubocop/packs/version'
+require_relative 'rubocop/packs/plugin'
 require_relative 'rubocop/packwerk_lite'
 
 require 'rubocop/cop/packs/root_namespace_is_pack_name'
 require 'rubocop/cop/packs/typed_public_apis'
 require 'rubocop/cop/packs/class_methods_as_public_apis'
 require 'rubocop/cop/packs/documented_public_apis'
-
-RuboCop::Packs::Inject.defaults!

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-packs
 version: !ruby/object:Gem::Version
-  version: 0.0.45
+  version: 0.1.1
 platform: ruby
 authors:
 - Gusto Engineers
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -16,30 +15,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
-  name: base64
+  name: lint_roller
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
-  name: bigdecimal
+  name: packs-specification
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +52,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: packs-specification
+  name: parse_packwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,55 +66,55 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: parse_packwerk
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.72'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.72'
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: rubocop-sorbet
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
-  name: rubocop-sorbet
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.4
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: sorbet-runtime
+  name: parser
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -123,35 +122,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.16
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.2.16
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: parser
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rubocop-extension-generator
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -165,21 +164,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rubocop-gusto
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rubocop-extension-generator
+  name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -220,6 +219,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A collection of Rubocop rules for gradually modularizing a ruby codebase
 email:
 - dev@gusto.com
@@ -240,10 +253,10 @@ files:
 - 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/plugin.rb
 - lib/rubocop/packs/private.rb
 - lib/rubocop/packs/private/configuration.rb
-- lib/rubocop/packs/private/offense.rb
+- lib/rubocop/packs/version.rb
 - lib/rubocop/packwerk_lite.rb
 homepage: https://github.com/rubyatscale/rubocop-packs
 licenses:
@@ -253,7 +266,7 @@ metadata:
   source_code_uri: https://github.com/rubyatscale/rubocop-packs
   changelog_uri: https://github.com/rubyatscale/rubocop-packs/releases
   allowed_push_host: https://rubygems.org
-post_install_message:
+  default_lint_roller_plugin: RuboCop::Packs::Plugin
 rdoc_options: []
 require_paths:
 - lib
@@ -261,15 +274,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.7'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: A collection of Rubocop rules for gradually modularizing a ruby codebase
 test_files: []

data/lib/rubocop/packs/inject.rb

@@ -1,24 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-# The original code is from https://github.com/rubocop/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
-# See https://github.com/rubocop/rubocop-rspec/blob/master/MIT-LICENSE.md
-module RuboCop
-  module Packs
-    # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
-    # bit of our configuration.
-    module Inject
-      extend T::Sig
-
-      sig { void }
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
-      end
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-# typed: strict
-
-module RuboCop
-  module Packs
-    module Private
-      class Offense < T::Struct
-        extend T::Sig
-
-        const :cop_name, String
-        const :filepath, String
-
-        sig { returns(T.nilable(::Packs::Pack)) }
-        def pack
-          ::Packs.for_file(filepath)
-        end
-      end
-    end
-  end
-end