gl_rubocop 0.5.5 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5609bd9d5a3b5e3fe6dded2031b9e86d4f51716b511a032205ed4e6564007c6a
-  data.tar.gz: 0b28be74b5a9a19773bdab6bec25f8dd4031eb7ed4dd53451af5609a330fb595
+  metadata.gz: 7ca20c8ca0cc4d308bc2d9e9c45163cefa6b31d0fcd180bec82709909ad821fb
+  data.tar.gz: 1e9b7359fa2212617b2bcc3873d47703e36e40c01afba7ce22ddfcc07684162d
 SHA512:
-  metadata.gz: fde9706801fcbd3f2eb95f1f02f8e85bda03a864a2e72e9b06ecf2b821b629f83e3b43cc6c8245db412afb30e0e425df79efb0bdfdd44b1b3ef34c66e7c52a9b
-  data.tar.gz: c9bb0a94e4bae6ea981de96f42bfe7d3ae69aef0703ce9afe35f7c53d6396bb381a689da7e8745365c34a3207a7fb836d0185680716458b4b656086d22dc0cfb
+  metadata.gz: 962abd8241aec7d0c7f31ddf561c71c5237b502b59fe83e7902d3bd0e6d5920d29a2a17fcef81c4a9e11b1d0520c3e12f3ce91ba0f83fb6bb0ffa06ea6f595f0
+  data.tar.gz: 93079a33074a9dd74dda1a17aaee79452000cd40495ce03f9570260c9ad7aed86d88e8c68b09cd35b5f7937edfc6ccf30475402ffc698ffb568b0c41413d4e56

data/default.yml

@@ -12,6 +12,9 @@ require:
   - ./lib/gl_rubocop/gl_cops/consolidate_request_system_specs.rb
   - ./lib/gl_rubocop/gl_cops/interactor_inherits_from_interactor_base.rb
   - ./lib/gl_rubocop/gl_cops/limit_flash_options.rb
+  - ./lib/gl_rubocop/gl_cops/no_controllers_outside_packs.rb
+  - ./lib/gl_rubocop/gl_cops/no_model_usage_in_controllers.rb
+  - ./lib/gl_rubocop/gl_cops/no_routes_outside_packs.rb
   - ./lib/gl_rubocop/gl_cops/no_stubbing_env.rb
   - ./lib/gl_rubocop/gl_cops/no_stubbing_perform_async.rb
   - ./lib/gl_rubocop/gl_cops/no_transaction_in_controllers.rb
@@ -34,7 +37,14 @@ AllCops:
   SuggestExtensions: false
   NewCops: enable
   Exclude:
-    - "config/**/*"
+    - "config/application.rb"
+    - "config/boot.rb"
+    - "config/environment.rb"
+    - "config/environments/**/*"
+    - "config/initializers/**/*"
+    - "config/locales/**/*"
+    - "config/puma.rb"
+    - "config/spring.rb"
     - "db/**/*"
     - "log/**/*"
     - "public/**/*"
@@ -67,6 +77,12 @@ GLCops/InteractorInheritsFromInteractorBase:
 GLCops/LimitFlashOptions:
   Enabled: true
 
+GLCops/NoControllersOutsidePacks:
+  Enabled: true
+  Include:
+    - "app/controllers/**/*"
+    - "packs/**/app/controllers/**/*"
+
 GLCops/NoHardcodedStringAssignmentToTextOrContentVariable:
   Enabled: true
   Include:
@@ -77,6 +93,21 @@ GLCops/NoHardcodedStringsInErbTextElements:
   Include:
     - "app/components/**/*.erb"
 
+GLCops/NoModelUsageInControllers:
+  Enabled: true
+  Include:
+    - "app/controllers/**/*"
+    - "packs/**/app/controllers/**/*"
+
+GLCops/NoRoutesOutsidePacks:
+  Enabled: true
+  Include:
+    - "config/routes.rb"
+    - "config/routes/**/*.rb"
+    - "packs/*/config/routes.rb"
+    - "packs/*/config/routes/**/*.rb"
+    - "packs/*/public/config/routes.rb"
+
 GLCops/NoStubbingEnv:
   Enabled: true
   Include:

data/lib/gl_rubocop/gl_cops/no_controllers_outside_packs.rb

@@ -0,0 +1,47 @@
+module GLRubocop
+  module GLCops
+    # This cop bans new controllers from being defined outside of a pack.
+    #
+    # Per our controller standards RFC, all new controllers must live within a pack
+    # (e.g. packs/my_pack/app/controllers) rather than the top-level app/controllers
+    # directory, so related functionality stays grouped together as we migrate the
+    # codebase to packs.
+    #
+    # The offense is determined by the file's own location (not just the `Include`
+    # config), so this cop only flags controllers whose file path does not contain a
+    # `packs/` segment. Existing controllers that predate this rule should be
+    # grandfathered in via an `Exclude` list in the consuming project's RuboCop config,
+    # so only newly added controllers are flagged.
+    #
+    # Good:
+    #   # packs/donations/app/controllers/donations_controller.rb
+    #   module Donations
+    #     class DonationsController < ApplicationController
+    #     end
+    #   end
+    #
+    # Bad:
+    #   # app/controllers/donations_controller.rb
+    #   class DonationsController < ApplicationController
+    #   end
+    class NoControllersOutsidePacks < RuboCop::Cop::Base
+      MSG = 'New controllers must be placed within a pack ' \
+            '(e.g. packs/my_pack/app/controllers), not app/controllers.'.freeze
+
+      PACK_PATH_SEGMENT = %r{(^|/)packs/}
+
+      def on_class(node)
+        return unless node.identifier.short_name.to_s.end_with?('Controller')
+        return if within_pack?
+
+        add_offense(node)
+      end
+
+      private
+
+      def within_pack?
+        PACK_PATH_SEGMENT.match?(processed_source.buffer.name.to_s)
+      end
+    end
+  end
+end

data/lib/gl_rubocop/gl_cops/no_model_usage_in_controllers.rb

@@ -0,0 +1,110 @@
+require_relative '../helpers/active_record_model_registry'
+
+module GLRubocop
+  module GLCops
+    # This cop bans direct ActiveRecord model usage (queries, persistence, and CRUD)
+    # inside controllers.
+    #
+    # Per our controller standards RFC, calling model methods directly in a controller
+    # entangles the networking/HTTP layer with the data layer. Query and persistence
+    # logic belongs in a GLCommand.
+    #
+    # Only constants confirmed (by scanning the app's model files) to transitively
+    # inherit from ApplicationRecord/ActiveRecord::Base are flagged, so plain Ruby
+    # objects that happen to live under app/models (wrappers, value objects, etc.) are
+    # not flagged.
+    #
+    # Good:
+    #   result = FindNonprofit.call(id: params[:id])
+    #
+    # Bad:
+    #   nonprofit = Nonprofit.find(params[:id])
+    #   nonprofit.update!(name: params[:name])
+    class NoModelUsageInControllers < RuboCop::Cop::Base
+      MSG = 'Do not use the `%<model>s` model directly in a controller. Move this ' \
+            'logic into a GLCommand.'.freeze
+
+      CLASS_LEVEL_METHODS = %i[
+        find find_by find_by! find_or_create_by find_or_create_by!
+        where create create! new all order includes joins pluck
+        exists? count first last update_all destroy_all
+      ].freeze
+
+      INSTANCE_LEVEL_METHODS = %i[save save! update update! destroy destroy!].freeze
+
+      def on_send(node)
+        receiver = node.receiver
+        return unless receiver
+
+        if receiver.const_type?
+          check_class_level_usage(node, receiver)
+        elsif receiver.lvar_type?
+          check_instance_level_usage(node, receiver)
+        end
+      end
+
+      def on_lvasgn(node)
+        var_name, value = *node
+        model_vars[var_name] = model_name_for(value.receiver) if assigns_model?(value)
+      end
+
+      def on_def(_node)
+        model_vars.clear
+      end
+      alias_method :on_defs, :on_def
+
+      private
+
+      def check_class_level_usage(node, receiver)
+        return unless CLASS_LEVEL_METHODS.include?(node.method_name)
+
+        model = model_name_for(receiver)
+        return unless model
+
+        add_offense(node, message: format(MSG, model:))
+      end
+
+      def check_instance_level_usage(node, receiver)
+        return unless INSTANCE_LEVEL_METHODS.include?(node.method_name)
+
+        model = model_vars[receiver.node_parts.first]
+        return unless model
+
+        add_offense(node, message: format(MSG, model:))
+      end
+
+      def assigns_model?(value)
+        value.respond_to?(:send_type?) && value.send_type? && value.receiver&.const_type?
+      end
+
+      def model_name_for(const_node)
+        name = full_const_name(const_node)
+        name if model_names.include?(name)
+      end
+
+      def full_const_name(node)
+        return nil unless node&.const_type?
+
+        namespace, name = *node
+        [namespace && full_const_name(namespace), name].compact.join('::')
+      end
+
+      def model_vars
+        @model_vars ||= {}
+      end
+
+      def model_names
+        GLRubocop::Helpers::ActiveRecordModelRegistry.for(project_root:,
+                                                          globs: model_globs)
+      end
+
+      def project_root
+        RuboCop::ConfigFinder.project_root
+      end
+
+      def model_globs
+        cop_config.fetch('ModelGlobs', GLRubocop::Helpers::ActiveRecordModelRegistry::DEFAULT_GLOBS)
+      end
+    end
+  end
+end

data/lib/gl_rubocop/gl_cops/no_routes_outside_packs.rb

@@ -0,0 +1,211 @@
+require_relative '../helpers/pack_controller_registry'
+
+module GLRubocop
+  module GLCops
+    # This cop flags route declarations for a pack-based controller when those routes
+    # are not defined within that pack's own routes file.
+    #
+    # Per our controller standards RFC, route declarations should live alongside the
+    # controllers they serve, so the relationship between routes and controllers stays
+    # clear and the codebase is easier to navigate.
+    #
+    # Only routes that resolve (via an explicit `to:`/`controller:` option, or an
+    # implicit `resources`/`resource` name) to a controller that lives in a pack are
+    # checked; routes for controllers outside of packs are always ignored. Pre-existing
+    # violations can be grandfathered in via the `Grandfathered` option (a list of
+    # controller paths, e.g. `receipt_copy/receipts`) so only newly introduced
+    # violations are flagged.
+    #
+    # Good:
+    #   # packs/tracking/config/routes/tracking.rb (packs/tracking/app/controllers/events_controller.rb)
+    #   namespace :tracking do
+    #     resources :events, only: :create
+    #   end
+    #
+    # Bad:
+    #   # config/routes.rb, for a controller defined in packs/tracking
+    #   namespace :tracking do
+    #     resources :events, only: :create
+    #   end
+    class NoRoutesOutsidePacks < RuboCop::Cop::Base
+      MSG = 'Routes for the `%<controller>s` controller must be defined in ' \
+            '%<expected_path>s (packs/%<pack>s), not here.'.freeze
+
+      NAMESPACING_METHODS = %i[namespace scope].freeze
+      RESOURCE_METHODS = %i[resources resource].freeze
+      MEMBER_ROUTE_METHODS = %i[get post put patch delete match].freeze
+
+      DEFAULT_ROUTES_PATH_TEMPLATE = 'packs/%<pack>s/public/config/routes.rb'.freeze
+      NON_PLURALIZING_Y_SUFFIXES = %w[ay ey iy oy uy].freeze
+
+      def on_new_investigation
+        walk(processed_source.ast, [])
+      end
+
+      private
+
+      def walk(node, namespace)
+        return unless node.is_a?(RuboCop::AST::Node)
+
+        if node.block_type?
+          walk_block(node, namespace)
+        elsif node.send_type?
+          check_route(node, namespace)
+          walk_children(node, namespace)
+        else
+          walk_children(node, namespace)
+        end
+      end
+
+      def walk_children(node, namespace)
+        node.children.each { |child| walk(child, namespace) if child.is_a?(RuboCop::AST::Node) }
+      end
+
+      def walk_block(node, namespace)
+        send_node = node.send_node
+        check_route(send_node, namespace)
+
+        child_namespace = namespace + Array(namespace_segment_for(send_node))
+        walk(node.body, child_namespace) if node.body
+      end
+
+      def check_route(send_node, namespace)
+        return unless send_node&.send_type?
+
+        if RESOURCE_METHODS.include?(send_node.method_name)
+          check_resource(send_node, namespace)
+        elsif MEMBER_ROUTE_METHODS.include?(send_node.method_name)
+          check_member_route(send_node, namespace)
+        end
+      end
+
+      def check_member_route(send_node, namespace)
+        to_value = keyword_value(send_node, :to)
+        return unless to_value&.str_type?
+
+        controller_part = to_value.value.to_s.split('#').first
+        # rubocop:disable Rails/Blank -- avoid depending on ActiveSupport, which
+        # gl_rubocop does not declare as a direct gem dependency.
+        return if controller_part.nil? || controller_part.empty?
+        # rubocop:enable Rails/Blank
+
+        check_controller_path(send_node, build_controller_path(namespace, controller_part))
+      end
+
+      def check_resource(send_node, namespace)
+        controller_part = explicit_controller_option(send_node) || resource_name_for(send_node,
+                                                                                     namespace)
+        return unless controller_part
+
+        check_controller_path(send_node, build_controller_path(namespace, controller_part))
+      end
+
+      def explicit_controller_option(send_node)
+        string_or_symbol_value(keyword_value(send_node, :controller))
+      end
+
+      def resource_name_for(send_node, namespace)
+        name = string_or_symbol_value(send_node.arguments.first)
+        return nil unless name
+        return name unless send_node.method_name == :resource
+
+        # `resource :checkout` conventionally maps to a pluralized controller
+        # (CheckoutsController), but some routes already pass the plural form
+        # directly (`resource :checkouts`) — prefer the name as-given when it
+        # already resolves to a known pack controller, to avoid double-pluralizing
+        # it (e.g. "checkouts" -> "checkoutses").
+        as_given_path = build_controller_path(namespace, name)
+        return name if controller_packs.key?(as_given_path)
+
+        pluralize(name)
+      end
+
+      def namespace_segment_for(send_node)
+        return nil unless send_node&.send_type?
+
+        return namespace_segment_from_arg(send_node) if send_node.method_name == :namespace
+        return namespace_segment_from_module_option(send_node) if send_node.method_name == :scope
+
+        nil
+      end
+
+      def namespace_segment_from_arg(send_node)
+        string_or_symbol_value(send_node.arguments.first)
+      end
+
+      def namespace_segment_from_module_option(send_node)
+        string_or_symbol_value(keyword_value(send_node, :module))
+      end
+
+      def string_or_symbol_value(node)
+        return nil unless node && (node.str_type? || node.sym_type?)
+
+        node.value.to_s
+      end
+
+      def keyword_value(send_node, key)
+        hash_arg = send_node.arguments.find(&:hash_type?)
+        return nil unless hash_arg
+
+        pair = hash_arg.pairs.find { |p| p.key.sym_type? && p.key.value == key }
+        pair&.value
+      end
+
+      def build_controller_path(namespace, controller_part)
+        return controller_part.delete_prefix('/') if controller_part.start_with?('/')
+
+        (namespace + [controller_part]).join('/')
+      end
+
+      def check_controller_path(node, controller_path)
+        pack_name = controller_packs[controller_path]
+        return unless pack_name
+        return if grandfathered.include?(controller_path)
+        return if defined_in_owning_pack_routes_file?(pack_name)
+
+        add_offense(node, message: format(MSG,
+                                          controller: controller_path,
+                                          pack: pack_name,
+                                          expected_path: format(routes_path_template,
+                                                                pack: pack_name)))
+      end
+
+      def defined_in_owning_pack_routes_file?(pack_name)
+        expected_suffix = format(routes_path_template, pack: pack_name)
+        processed_source.path.to_s.end_with?(expected_suffix)
+      end
+
+      def pluralize(word)
+        return "#{word.delete_suffix('y')}ies" if pluralizes_to_ies?(word)
+        return "#{word}es" if word.end_with?('s', 'x', 'z', 'ch', 'sh')
+
+        "#{word}s"
+      end
+
+      def pluralizes_to_ies?(word)
+        word.end_with?('y') && NON_PLURALIZING_Y_SUFFIXES.none? { |suffix| word.end_with?(suffix) }
+      end
+
+      def controller_packs
+        GLRubocop::Helpers::PackControllerRegistry.for(project_root:, globs: controller_globs)
+      end
+
+      def project_root
+        RuboCop::ConfigFinder.project_root
+      end
+
+      def controller_globs
+        cop_config.fetch('ControllerGlobs',
+                         GLRubocop::Helpers::PackControllerRegistry::DEFAULT_GLOBS)
+      end
+
+      def routes_path_template
+        cop_config.fetch('RoutesPathTemplate', DEFAULT_ROUTES_PATH_TEMPLATE)
+      end
+
+      def grandfathered
+        cop_config.fetch('Grandfathered', [])
+      end
+    end
+  end
+end

data/lib/gl_rubocop/helpers/active_record_model_registry.rb

@@ -0,0 +1,138 @@
+require 'set'
+require 'parser/current'
+
+module GLRubocop
+  module Helpers
+    class ActiveRecordModelRegistry
+      DEFAULT_GLOBS = [
+        'app/models/**/*.rb',
+        'packs/*/app/models/**/*.rb'
+      ].freeze
+
+      AR_BASE_CLASSES = ['ApplicationRecord', 'ActiveRecord::Base'].freeze
+
+      class << self
+        def for(project_root:, globs: DEFAULT_GLOBS)
+          @cache ||= {}
+          @cache[[project_root,
+                  globs]] ||= new(project_root:, globs:).model_names
+        end
+
+        def reset_cache!
+          @cache = {}
+        end
+      end
+
+      def initialize(project_root:, globs:)
+        @project_root = project_root
+        @globs = globs
+      end
+
+      def model_names
+        parents = collect_class_parents
+        Set.new(parents.keys.select { |name| ar_derived?(name, parents) })
+      end
+
+      private
+
+      attr_reader :project_root, :globs
+
+      def collect_class_parents
+        parents = {}
+        globs.each do |glob|
+          Dir.glob(File.join(project_root, glob)).each do |path|
+            next unless File.file?(path)
+
+            walk_classes(parse(path), [], parents)
+          end
+        end
+        parents
+      end
+
+      def parse(path)
+        Parser::CurrentRuby.parse(File.read(path))
+      rescue Parser::SyntaxError, EncodingError
+        nil
+      end
+
+      def walk_classes(node, namespace, parents)
+        return unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :module
+          walk_module(node, namespace, parents)
+        when :class
+          walk_class(node, namespace, parents)
+        else
+          walk_children(node, namespace, parents)
+        end
+      end
+
+      def walk_module(node, namespace, parents)
+        walk_body(node.children[1], namespace + [const_name(node.children[0])], parents)
+      end
+
+      def walk_class(node, namespace, parents)
+        name = namespace + [const_name(node.children[0])]
+        parent = node.children[1] && const_name(node.children[1])
+        parents[name.join('::')] = { parent:, namespace: }
+        walk_body(node.children[2], name, parents)
+      end
+
+      def walk_children(node, namespace, parents)
+        node.children.each do |child|
+          walk_classes(child, namespace, parents) if child.is_a?(Parser::AST::Node)
+        end
+      end
+
+      def walk_body(body, namespace, parents)
+        return unless body
+
+        if body.type == :begin
+          body.children.each { |child| walk_classes(child, namespace, parents) }
+        else
+          walk_classes(body, namespace, parents)
+        end
+      end
+
+      def const_name(node)
+        return nil unless node
+
+        parts = []
+        current = node
+        while current&.type == :const
+          parts.unshift(current.children[1].to_s)
+          current = current.children[0]
+        end
+        parts.join('::')
+      end
+
+      def ar_derived?(name, parents, seen = {})
+        return seen[name] if seen.key?(name)
+        return true if AR_BASE_CLASSES.include?(name)
+
+        info = parents[name]
+        return false unless info
+
+        seen[name] = false
+        parent = info[:parent]
+        return false unless parent
+
+        resolved_parent = resolve_const(parent, info[:namespace], parents)
+        result = ar_derived?(resolved_parent, parents, seen)
+        seen[name] = result
+        result
+      end
+
+      def resolve_const(name, namespace, parents)
+        return name if parents.key?(name)
+
+        namespace.size.downto(0) do |i|
+          candidate = (namespace[0...i] + [name]).join('::')
+          return candidate if parents.key?(candidate)
+        end
+        name
+      end
+    end
+  end
+end

data/lib/gl_rubocop/helpers/pack_controller_registry.rb

@@ -0,0 +1,132 @@
+require 'parser/current'
+
+module GLRubocop
+  module Helpers
+    # Scans a project's packs for controller classes and maps each controller's Rails
+    # controller path (e.g. `'receipt_copy/receipts'`) to the name of the pack that
+    # defines it. Controller paths are derived from the controller's fully namespaced
+    # class name (mirroring how Rails computes `controller_path`), not from the file's
+    # location on disk, since some packs place controllers under `app/public` instead
+    # of `app/controllers`.
+    class PackControllerRegistry
+      DEFAULT_GLOBS = [
+        'packs/*/app/controllers/**/*.rb',
+        'packs/*/app/public/**/*_controller.rb'
+      ].freeze
+
+      class << self
+        def for(project_root:, globs: DEFAULT_GLOBS)
+          @cache ||= {}
+          @cache[[project_root, globs]] ||= new(project_root:, globs:).controller_packs
+        end
+
+        def reset_cache!
+          @cache = {}
+        end
+      end
+
+      def initialize(project_root:, globs:)
+        @project_root = project_root
+        @globs = globs
+      end
+
+      # Returns a Hash of controller_path (String) => pack_name (String)
+      def controller_packs
+        mapping = {}
+        globs.each do |glob|
+          Dir.glob(File.join(project_root, glob)).each { |path| collect(path, mapping) }
+        end
+        mapping
+      end
+
+      private
+
+      attr_reader :project_root, :globs
+
+      def collect(path, mapping)
+        return unless File.file?(path)
+
+        pack_name = pack_name_for(path)
+        return unless pack_name
+
+        controller_paths_in(path).each { |controller_path| mapping[controller_path] = pack_name }
+      end
+
+      def pack_name_for(path)
+        relative = path.delete_prefix("#{project_root}/")
+        match = relative.match(%r{\Apacks/([^/]+)/})
+        match && match[1]
+      end
+
+      def controller_paths_in(path)
+        ast = parse(path)
+        return [] unless ast
+
+        paths = []
+        walk_classes(ast, [], paths)
+        paths
+      end
+
+      def parse(path)
+        Parser::CurrentRuby.parse(File.read(path))
+      rescue Parser::SyntaxError, EncodingError
+        nil
+      end
+
+      def walk_classes(node, namespace, paths)
+        return unless node.is_a?(Parser::AST::Node)
+
+        case node.type
+        when :module
+          walk_body(node.children[1], namespace + [const_name(node.children[0])], paths)
+        when :class
+          walk_class(node, namespace, paths)
+        else
+          node.children.each do |child|
+            walk_classes(child, namespace, paths) if child.is_a?(Parser::AST::Node)
+          end
+        end
+      end
+
+      def walk_class(node, namespace, paths)
+        full_name = (namespace + [const_name(node.children[0])]).join('::')
+        paths << controller_path_for(full_name) if full_name.end_with?('Controller')
+        walk_body(node.children[2], namespace + [const_name(node.children[0])], paths)
+      end
+
+      def walk_body(body, namespace, paths)
+        return unless body
+
+        if body.type == :begin
+          body.children.each { |child| walk_classes(child, namespace, paths) }
+        else
+          walk_classes(body, namespace, paths)
+        end
+      end
+
+      def const_name(node)
+        return nil unless node
+
+        parts = []
+        current = node
+        while current&.type == :const
+          parts.unshift(current.children[1].to_s)
+          current = current.children[0]
+        end
+        parts.join('::')
+      end
+
+      def controller_path_for(full_class_name)
+        underscore(full_class_name.delete_suffix('Controller'))
+      end
+
+      def underscore(camel_cased_word)
+        camel_cased_word.gsub('::', '/')
+                        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                        .tr('-', '_')
+                        .downcase
+      end
+    end
+  end
+end

data/lib/gl_rubocop/version.rb

@@ -1,3 +1,3 @@
 module GLRubocop
-  VERSION = '0.5.5'.freeze
+  VERSION = '0.6.0'.freeze
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: gl_rubocop
 version: !ruby/object:Gem::Version
-  version: 0.5.5
+  version: 0.6.0
 platform: ruby
 authors:
 - Give Lively
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-06 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubocop
@@ -150,8 +149,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description:
-email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -166,8 +163,11 @@ files:
 - lib/gl_rubocop/gl_cops/consolidate_request_system_specs.rb
 - lib/gl_rubocop/gl_cops/interactor_inherits_from_interactor_base.rb
 - lib/gl_rubocop/gl_cops/limit_flash_options.rb
+- lib/gl_rubocop/gl_cops/no_controllers_outside_packs.rb
 - lib/gl_rubocop/gl_cops/no_hardcoded_string_assignment_to_text_or_content_variable.rb
 - lib/gl_rubocop/gl_cops/no_hardcoded_strings_in_erb_text_elements.rb
+- lib/gl_rubocop/gl_cops/no_model_usage_in_controllers.rb
+- lib/gl_rubocop/gl_cops/no_routes_outside_packs.rb
 - lib/gl_rubocop/gl_cops/no_stubbing_env.rb
 - lib/gl_rubocop/gl_cops/no_stubbing_perform_async.rb
 - lib/gl_rubocop/gl_cops/no_transaction_in_controllers.rb
@@ -183,15 +183,16 @@ files:
 - lib/gl_rubocop/gl_cops/view_component_directory_structure.rb
 - lib/gl_rubocop/gl_cops/view_component_inheritance.rb
 - lib/gl_rubocop/gl_cops/view_component_initialize_keyword_args.rb
+- lib/gl_rubocop/helpers/active_record_model_registry.rb
 - lib/gl_rubocop/helpers/erb_content_helper.rb
 - lib/gl_rubocop/helpers/haml_content_helper.rb
+- lib/gl_rubocop/helpers/pack_controller_registry.rb
 - lib/gl_rubocop/version.rb
 homepage: https://github.com/givelively/gl_rubocop
 licenses:
 - MIT
 metadata:
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -206,8 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-signing_key:
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A shareable configuration of Give Lively's rubocop rules.
 test_files: []