rubocop-packs 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8dd71f6422be7332808603d1237a03e40a919fd9a49e7f5cc0e2e70ef1543f83
-  data.tar.gz: f7ec591736305bbe8e8acff73c3abda3efdbf2afd53bfb9b9363182e2b8473bf
+  metadata.gz: c6fb879c4fde42e92de3719345a90fd8782cfd9239ec7845869df3ef942ed8b0
+  data.tar.gz: 1c2a8ad04b824ed3f5c4a5ea69032164c60057a12a45b8d2d1985b2baaa863c1
 SHA512:
-  metadata.gz: 9502ccc3746e1ae9f6ee3801fe78330ece03aad0934729ab33c560c73a4ce226cb7f8e3e0726e8da9509b9495e7e06be991cd927d6709a15601c89dc47178fec
-  data.tar.gz: e917ea12928f8cf3e8ab20496261fbb0f9672708b4114b0254fb3df96eb0735f6893d7413f19aaf6d181ae0089040e1356d5e6a49fb3190dd9cda7730599edd5
+  metadata.gz: 0f628b8204e0124712c8a760bc52c1f5a6b15dafe7f9fa48d6d05d9e40bc0b6e86c46f43441c535936e9182314718e27a4afc33d0a7eed33297f7a14d3317be8
+  data.tar.gz: 3d88bf6ee823725ba651add5983792096e59bd7ebe3229028edb03dbb1029002270f96a3cc64d3fa47e6963e7b2b97828f64b0583ff60ee0f1a65920971ff041

data/config/default.yml

@@ -23,6 +23,8 @@ 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.'

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

@@ -29,9 +29,7 @@ module RuboCop
       #   end
       #
       class ClassMethodsAsPublicApis < Base
-        extend T::Sig
-
-        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/')
@@ -59,7 +57,7 @@ module RuboCop
 
         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?

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -30,22 +31,155 @@ 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 { params(node: T.untyped).void }
+        # 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
+
+        # `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_method?(node) && !require_for_non_public_methods?
 
           left_sibling = node.left_sibling
 
@@ -67,19 +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)
-          # 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`.
-          return false if !node.is_a?(RuboCop::AST::Node)
+          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 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
+        # 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
 
-          # 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 {')))
+        #: (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
 
@@ -52,22 +66,25 @@ module RuboCop
             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}/), '')
             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)
@@ -83,10 +82,9 @@ module RuboCop
 
         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,23 +13,37 @@ 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).
@@ -33,7 +51,7 @@ module RuboCop
             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('::')
@@ -68,13 +86,13 @@ module RuboCop
 
             return if !expected_pack_contains_constant
 
-            found_file = found_files.first
+            found_file = found_files.fetch(0)
 
             ConstantReference.new(
               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,9 +38,7 @@ module RuboCop
       #   #   - packs/bar
       #
       class Dependency < Base
-        extend T::Sig
-
-        sig { params(node: RuboCop::AST::ConstNode).void }
+        #: (RuboCop::AST::ConstNode node) -> void
         def on_const(node)
           return if Private.partial_const_reference?(node)
 

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

@@ -1,4 +1,5 @@
 # typed: strict
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -38,9 +39,7 @@ module RuboCop
       #   end
       #
       class Privacy < Base
-        extend T::Sig
-
-        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)

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

@@ -7,9 +7,7 @@ module RuboCop
   module Packs
     # A plugin that integrates rubocop-packs with RuboCop's plugin system.
     class Plugin < LintRoller::Plugin
-      extend T::Sig
-
-      sig { returns(LintRoller::About) }
+      #: -> LintRoller::About
       def about
         LintRoller::About.new(
           name: 'rubocop-packs',
@@ -19,12 +17,12 @@ module RuboCop
         )
       end
 
-      sig { params(context: LintRoller::Context).returns(T::Boolean) }
+      #: (LintRoller::Context context) -> bool
       def supported?(context)
         context.engine == :rubocop
       end
 
-      sig { params(_context: LintRoller::Context).returns(LintRoller::Rules) }
+      #: (LintRoller::Context _context) -> LintRoller::Rules
       def rules(_context)
         LintRoller::Rules.new(
           type: :path,

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

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

data/lib/rubocop/packs.rb

@@ -5,23 +5,21 @@ require 'rubocop/packs/private'
 
 module RuboCop
   module Packs
-    extend T::Sig
-
-    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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-packs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Gusto Engineers
@@ -15,54 +15,26 @@ dependencies:
     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: base64
-  requirement: !ruby/object:Gem::Requirement
-    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'
-- !ruby/object:Gem::Dependency
-  name: bigdecimal
-  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'
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: lint_roller
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
@@ -97,14 +69,14 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.72'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.72'
 - !ruby/object:Gem::Dependency
@@ -121,20 +93,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.0
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  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: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -181,14 +139,14 @@ dependencies:
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
@@ -298,7 +256,6 @@ files:
 - 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

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