rubocop-thoughtbot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 56b7014c878946a04e2619ecb8a50cd7e2cd60199c4c4e3ea4fd362ca601b3e0
+  data.tar.gz: 964048a771865a0092dd7461cfe3205bc8365818c62fd10302065fee2665f4c8
+SHA512:
+  metadata.gz: ce3ee7c537f213881a88c69798f2ffd282a7a124446b96034b2715b09b8491246399fc8a584ff0810e065f7928213ccb1a530441784922c1dcdfe9df865d6737
+  data.tar.gz: ff3e7287274ab79cc20953993a44bd3edd2c456b7b529156b7b2ac26a54b22ab152a00dc2b41757901200a003507f91be650b27c4c9f271ba759fd194fd54b34

data/.tool-versions

@@ -0,0 +1 @@
+ruby 4.0.6

data/BELIEFS.md

@@ -0,0 +1,37 @@
+# Beliefs
+
+This gem is a set of opinions about writing Ruby and Rails, but this isn't where
+those live (each cop carries its own argument, in its documentation).
+
+This is the layer above: what we believe about building the cops, and about the
+experience of the person on the receiving end of one.
+
+Every entry states a belief, then how it applies. If an entry can't produce a
+practical half, it isn't a belief we hold yet, it's a preference still looking
+for its justification.
+
+## Offence messages teach
+
+The reader may be meeting this convention for the first time, and the message
+may be the only documentation they ever read. Editors truncate, CI logs scroll,
+and nobody clicks through to a rule reference they didn't go looking for. A
+message that assumes you already know the convention only helps the people who
+didn't need it.
+
+So a message has to stand on its own: name what is wrong here, say what to do
+about it, and leave the reader somewhere to go for the reasoning.
+
+Complete beats short. But a message is paid for once per offence, and these cops
+can fire several times in a single file. Every clause has to earn its place on
+the twentieth line of a CI log.
+
+**In practice**
+
+- Name the specific code, interpolated — `` `edit_password` ``, not "this method".
+- State the remedy, not just the violation. Where there is more than one, list them.
+- Give the why in a clause, where one fits.
+- Link the reasoning. If there's no article justifying the cop, write the article
+  before writing the cop.
+- Address the code, never the developer. "Avoid `let`", not "don't use `let`".
+- Put worked examples in the cop's `@example` blocks. A message is one line and
+  can't hold them.

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-07-29
+
+- Initial release
+  - See [README](README.md) for context
+  - Releases with only [3 cops](docs/modules/ROOT/pages/cops_thoughtbot.adoc) to get started. Expect more as we iterate

data/CODEOWNERS

@@ -0,0 +1,4 @@
+# Defines who is responsible for code in the codebase
+# https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+
+* @jaredlt

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"rubocop-thoughtbot" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at ["jared.turner@thoughtbot.com"](mailto:"jared.turner@thoughtbot.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Jared Turner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,157 @@
+# RuboCop::Thoughtbot
+
+A [RuboCop] and [Standard] plugin based on thoughtbot's accumulated best-practices.
+
+[RuboCop]: https://rubocop.org
+[Standard]: https://github.com/standardrb/standard
+
+## Why?
+
+We believe there is more that linting can solve. And it's not just style debates
+about quotes or spaces.
+
+- The mystery guest `let` that lives 150 lines from the spec example, causing
+  [confusion and hours lost debugging]
+- The controller that grows an `activate` action, then a `publish`, until
+  [nothing about the file is predictable]
+
+These are patterns we see repeated from human developers and AIs alike. For humans,
+we solve this during code review, but slowly, inconsistently, and one developer
+at a time. For AI, we put [guidance] into `CLAUDE.md` or `AGENTS.md`. But steering
+an LLM is probabilistic, whereas a linter is deterministic. Linters let us move the
+feedback loop left, into the developer's editor and into the [agent's hooks]. That's
+what guides a codebase towards good practices and good architecture (the things that
+keep it clean and easy to maintain in 2 years time).
+
+A faster loop only helps if the feedback teaches. The person reading a message may
+be meeting the convention for the first time, and it may be the only documentation
+they ever read. A message that assumes the convention is already understood only
+helps the people who didn't need it. So each cop carries its argument with it: the
+message names what's wrong, says what to do about it, and links the reasoning.
+
+[confusion and hours lost debugging]: https://thoughtbot.com/blog/lets-not
+[nothing about the file is predictable]: https://thoughtbot.com/blog/in-relentless-pursuit-of-rest-ish-routing
+[guidance]: https://github.com/thoughtbot/guides/tree/main/rails/ai-rules
+[agent's hooks]: https://thoughtbot.com/blog/enforcing-your-ruby-style-guide-on-ai-generated-code
+
+## What to expect
+
+These cops are our opinions on clean code and maintainable software. The intention
+is for you to layer these on top of Standard, or your own RuboCop config.
+
+In time, we might be able to upstream some of them, but we're releasing a separate
+Gem to give us the freedom to rapidly experiment and iterate across a wide range of
+codebases first.
+
+Linting works great for things that are deterministic, but there are plenty of best
+practices where "it depends". Where a rule is _generally_ true we think the linting
+guidance outweighs the occasional false positive (and you can exclude the files where
+it genuinely doesn't apply). We won't always get this right, and a cop that turns out
+to be more trouble than it's worth will be removed.
+
+## Installation
+
+This gem is not published to RubyGems yet, so install it from GitHub. Add it to
+your Gemfile:
+
+```ruby
+group :development, :test do
+  gem "rubocop-thoughtbot", github: "thoughtbot/rubocop-thoughtbot", require: false
+  # Or via SSH while the repo is private
+  # gem "rubocop-thoughtbot", git: "git@github.com:thoughtbot/rubocop-thoughtbot.git", require: false
+end
+```
+
+Then run `bundle install`.
+
+Next, tell your linter to load the plugin.
+
+### RuboCop
+
+In `.rubocop.yml`:
+
+```yaml
+plugins:
+  - rubocop-thoughtbot
+```
+
+### Standard
+
+In `.standard.yml`:
+
+```yaml
+plugins:
+  - rubocop-thoughtbot
+```
+
+## Usage
+
+Run your linter as usual and the cops are applied:
+
+```bash
+bundle exec rubocop
+# or
+bundle exec standardrb
+```
+
+## Show me the cops!
+
+All cops are located under [`lib/rubocop/cop/thoughtbot`](lib/rubocop/cop/thoughtbot),
+or you can [view the docs](docs/modules/ROOT/pages/cops_thoughtbot.adoc).
+
+### Excluding files
+
+Each cop is a single opinion and doesn't take options (the knobs it might expose
+would only let you turn down the argument it's making). Where a convention
+genuinely doesn't apply, exclude the file rather than reaching for a setting. An
+OmniAuth callbacks controller is the usual example: its actions are named by the
+provider, so the `ResourcefulActions` cop isn't helpful.
+
+In `.rubocop.yml`:
+
+```yaml
+Thoughtbot/ResourcefulActions:
+  Exclude:
+    - "app/controllers/users/omniauth_callbacks_controller.rb"
+```
+
+In `.standard.yml`, exclusions go under `ignore` rather than under the cop:
+
+```yaml
+plugins:
+  - rubocop-thoughtbot
+ignore:
+  - 'app/controllers/users/omniauth_callbacks_controller.rb':
+    - Thoughtbot/ResourcefulActions
+```
+
+For a single occurrence rather than a whole file, use an inline disable comment:
+
+`# rubocop:disable Thoughtbot/ResourcefulActions`, or `# standard:disable Thoughtbot/ResourcefulActions`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+### Commands
+
+- `bundle exec rake 'new_cop[Thoughtbot/CopName]'` # Generate new cop (always run this rather than creating the files directly)
+- `bundle exec rspec`         # Tests
+- `bundle exec rubocop`       # Lint
+- `bundle exec rubocop -a`    # Auto-fix lint issues
+- `bundle exec rake docs`     # Re-generate docs
+- `bundle exec rake`          # Run all: Specs, lint, docs
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/rubocop-thoughtbot. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/rubocop-thoughtbot/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rubocop::Thoughtbot project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/rubocop-thoughtbot/blob/main/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+require "rubocop/rake_task"
+require "yard"
+
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.verbose = false
+end
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop verify_docs]
+
+YARD::Rake::YardocTask.new(:yard_registry) do |task|
+  task.files = ["lib/rubocop/cop/**/*.rb"]
+  task.options = ["--no-output", "--no-progress", "--no-stats"]
+end
+
+desc "Generate cop documentation from the cops' YARD comments"
+task docs: :yard_registry do
+  require "rubocop"
+  require "rubocop/cops_documentation_generator"
+
+  CopsDocumentationGenerator.new(
+    departments: ["Thoughtbot"],
+    plugin_name: "rubocop-thoughtbot"
+  ).call
+end
+
+desc "Check the committed cop documentation still matches the cops"
+task verify_docs: :docs do
+  drift = `git status --porcelain -- docs`
+
+  unless drift.empty?
+    abort <<~MESSAGE
+      Generated cop documentation is out of date:
+
+      #{drift}
+      `rake docs` has already regenerated it. Review and commit `docs/`.
+    MESSAGE
+  end
+end
+
+desc "Generate a new cop with a template"
+task :new_cop, [:cop] do |_task, args|
+  require "rubocop"
+
+  cop_name = args.fetch(:cop) do
+    warn "usage: bundle exec rake new_cop[Department/Name]"
+    exit!
+  end
+
+  generator = RuboCop::Cop::Generator.new(cop_name)
+
+  generator.write_source
+  generator.write_spec
+  generator.inject_require(root_file_path: "lib/rubocop/cop/thoughtbot_cops.rb")
+  generator.inject_config(config_file_path: "config/default.yml")
+
+  puts generator.todo
+end

data/config/default.yml

@@ -0,0 +1,26 @@
+Thoughtbot:
+  DocumentationBaseURL: https://github.com/thoughtbot/rubocop-thoughtbot/blob/main/docs/modules/ROOT/pages
+  DocumentationExtension: '.adoc'
+
+Thoughtbot/NoBefore:
+  Description: 'Checks for `before` hooks in specs.'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Include:
+    - '**/*_spec.rb'
+    - '**/spec/**/*.rb'
+
+Thoughtbot/NoLet:
+  Description: 'Checks for `let` and `let!` declarations in specs.'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Include:
+    - '**/*_spec.rb'
+    - '**/spec/**/*.rb'
+
+Thoughtbot/ResourcefulActions:
+  Description: 'Checks for public methods in Rails controllers outside the seven resourceful actions.'
+  Enabled: true
+  VersionAdded: '0.1.0'
+  Include:
+    - '**/app/controllers/**/*.rb'

data/docs/modules/ROOT/pages/cops.adoc

@@ -0,0 +1,5 @@
+=== Department xref:cops_thoughtbot.adoc[Thoughtbot]
+
+* xref:cops_thoughtbot.adoc#thoughtbotnobefore[Thoughtbot/NoBefore]
+* xref:cops_thoughtbot.adoc#thoughtbotnolet[Thoughtbot/NoLet]
+* xref:cops_thoughtbot.adoc#thoughtbotresourcefulactions[Thoughtbot/ResourcefulActions]

data/docs/modules/ROOT/pages/cops_thoughtbot.adoc

@@ -0,0 +1,201 @@
+////
+  Do NOT edit this file by hand directly, as it is automatically generated.
+
+  Please make any necessary changes to the cop documentation within the source files themselves.
+////
+
+= Thoughtbot
+
+[#thoughtbotnobefore]
+== Thoughtbot/NoBefore
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 0.1.0
+| -
+|===
+
+Checks for `before` hooks in specs.
+
+Setup in a `before` sits away from the examples that use it, so a
+reader has to jump around the file to work out what any one example is
+actually doing (the `before` becomes a mystery guest). Setting data up
+inside each example keeps the whole story of the test in one place,
+avoids messy overrides for differing scenarios, and keeps the cost of
+setup visible.
+
+See https://thoughtbot.com/blog/lets-not
+
+See https://thoughtbot.com/blog/the-arrange-act-assert-pattern
+
+[#examples-thoughtbotnobefore]
+=== Examples
+
+[source,ruby]
+----
+# bad
+before { @user = build(:user) }
+
+it "is valid" do
+  expect(@user).to be_valid
+end
+
+# good
+it "is valid" do
+  user = build(:user)
+
+  expect(user).to be_valid
+end
+----
+
+[#configurable-attributes-thoughtbotnobefore]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Include
+| `+**/*_spec.rb+`, `+**/spec/**/*.rb+`
+| Array
+|===
+
+[#thoughtbotnolet]
+== Thoughtbot/NoLet
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 0.1.0
+| -
+|===
+
+Checks for `let` and `let!` declarations in specs.
+
+Data defined in a `let` sits away from the examples that use it, so a
+reader has to jump around the file to work out what any one example is
+actually doing (the `let` becomes a mystery guest). Setting data up
+inside each example keeps the whole story of the test in one place,
+avoids messy overrides for differing scenarios, and keeps the cost of
+setup visible.
+
+See https://thoughtbot.com/blog/lets-not
+
+See https://thoughtbot.com/blog/the-arrange-act-assert-pattern
+
+[#examples-thoughtbotnolet]
+=== Examples
+
+[source,ruby]
+----
+# bad
+let(:user) { build(:user) }
+
+it "is valid" do
+  expect(user).to be_valid
+end
+
+# good
+it "is valid" do
+  user = build(:user)
+
+  expect(user).to be_valid
+end
+----
+
+[#configurable-attributes-thoughtbotnolet]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Include
+| `+**/*_spec.rb+`, `+**/spec/**/*.rb+`
+| Array
+|===
+
+[#thoughtbotresourcefulactions]
+== Thoughtbot/ResourcefulActions
+
+|===
+| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed
+
+| Enabled
+| Yes
+| No
+| 0.1.0
+| -
+|===
+
+Checks for public methods in Rails controllers outside the seven
+resourceful actions: `index`, `show`, `new`, `edit`, `create`,
+`update` and `destroy`.
+
+A custom action needs a custom route, and custom routes pick their
+verbs ad hoc (`update-password`, `add-payment-method`, `activate`)
+so no two read the same way. Sticking to the seven constrains you to
+the standard HTTP verbs and pushes the naming into nouns, which are
+far less ambiguous than invented verbs. It also keeps controllers
+small, since the fix for a new action is a new controller.
+
+Rails routes any public instance method on a controller, so this cop
+also flags helpers left public. Those should be private.
+
+Controllers dictated by a gem (`Devise::OmniauthCallbacksController`
+with an action per provider, or Doorkeeper's OAuth endpoints) can't
+follow the convention. Exclude them:
+
+  Thoughtbot/ResourcefulActions:
+    Exclude:
+      - "app/controllers/users/omniauth_callbacks_controller.rb"
+
+See https://thoughtbot.com/blog/in-relentless-pursuit-of-rest-ish-routing
+
+[#examples-thoughtbotresourcefulactions]
+=== Examples
+
+[source,ruby]
+----
+# bad
+class UsersController < ApplicationController
+  def activate
+  end
+end
+
+# good
+class Users::ActivationsController < ApplicationController
+  def create
+  end
+end
+
+# bad
+class ApplicationController < ActionController::Base
+  def current_user
+  end
+end
+
+# good
+class ApplicationController < ActionController::Base
+  private
+
+  def current_user
+  end
+end
+----
+
+[#configurable-attributes-thoughtbotresourcefulactions]
+=== Configurable attributes
+
+|===
+| Name | Default value | Configurable values
+
+| Include
+| `+**/app/controllers/**/*.rb+`
+| Array
+|===

data/lib/rubocop/cop/thoughtbot/no_before.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Thoughtbot
+      # Checks for `before` hooks in specs.
+      #
+      # Setup in a `before` sits away from the examples that use it, so a
+      # reader has to jump around the file to work out what any one example is
+      # actually doing (the `before` becomes a mystery guest). Setting data up
+      # inside each example keeps the whole story of the test in one place,
+      # avoids messy overrides for differing scenarios, and keeps the cost of
+      # setup visible.
+      #
+      # See https://thoughtbot.com/blog/lets-not
+      #
+      # See https://thoughtbot.com/blog/the-arrange-act-assert-pattern
+      #
+      # @example
+      #   # bad
+      #   before { @user = build(:user) }
+      #
+      #   it "is valid" do
+      #     expect(@user).to be_valid
+      #   end
+      #
+      #   # good
+      #   it "is valid" do
+      #     user = build(:user)
+      #
+      #     expect(user).to be_valid
+      #   end
+      #
+      class NoBefore < Base
+        MSG = "Avoid `before` — set up test data inside each example so it " \
+              "doesn't become a mystery guest. See https://thoughtbot.com/blog/lets-not"
+
+        RESTRICT_ON_SEND = %i[before].freeze
+
+        def on_send(node)
+          return if node.receiver
+
+          add_offense(node.loc.selector)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thoughtbot/no_let.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Thoughtbot
+      # Checks for `let` and `let!` declarations in specs.
+      #
+      # Data defined in a `let` sits away from the examples that use it, so a
+      # reader has to jump around the file to work out what any one example is
+      # actually doing (the `let` becomes a mystery guest). Setting data up
+      # inside each example keeps the whole story of the test in one place,
+      # avoids messy overrides for differing scenarios, and keeps the cost of
+      # setup visible.
+      #
+      # See https://thoughtbot.com/blog/lets-not
+      #
+      # See https://thoughtbot.com/blog/the-arrange-act-assert-pattern
+      #
+      # @example
+      #   # bad
+      #   let(:user) { build(:user) }
+      #
+      #   it "is valid" do
+      #     expect(user).to be_valid
+      #   end
+      #
+      #   # good
+      #   it "is valid" do
+      #     user = build(:user)
+      #
+      #     expect(user).to be_valid
+      #   end
+      #
+      class NoLet < Base
+        MSG = "Avoid `%<method>s` — set up test data inside each example so it " \
+              "doesn't become a mystery guest. See https://thoughtbot.com/blog/lets-not"
+
+        RESTRICT_ON_SEND = %i[let let!].freeze
+
+        def on_send(node)
+          return if node.receiver
+
+          add_offense(node.loc.selector, message: format(MSG, method: node.method_name))
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thoughtbot/resourceful_actions.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Thoughtbot
+      # Checks for public methods in Rails controllers outside the seven
+      # resourceful actions: `index`, `show`, `new`, `edit`, `create`,
+      # `update` and `destroy`.
+      #
+      # A custom action needs a custom route, and custom routes pick their
+      # verbs ad hoc (`update-password`, `add-payment-method`, `activate`)
+      # so no two read the same way. Sticking to the seven constrains you to
+      # the standard HTTP verbs and pushes the naming into nouns, which are
+      # far less ambiguous than invented verbs. It also keeps controllers
+      # small, since the fix for a new action is a new controller.
+      #
+      # Rails routes any public instance method on a controller, so this cop
+      # also flags helpers left public. Those should be private.
+      #
+      # Controllers dictated by a gem (`Devise::OmniauthCallbacksController`
+      # with an action per provider, or Doorkeeper's OAuth endpoints) can't
+      # follow the convention. Exclude them:
+      #
+      #   Thoughtbot/ResourcefulActions:
+      #     Exclude:
+      #       - "app/controllers/users/omniauth_callbacks_controller.rb"
+      #
+      # See https://thoughtbot.com/blog/in-relentless-pursuit-of-rest-ish-routing
+      #
+      # @example
+      #   # bad
+      #   class UsersController < ApplicationController
+      #     def activate
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Users::ActivationsController < ApplicationController
+      #     def create
+      #     end
+      #   end
+      #
+      #   # bad
+      #   class ApplicationController < ActionController::Base
+      #     def current_user
+      #     end
+      #   end
+      #
+      #   # good
+      #   class ApplicationController < ActionController::Base
+      #     private
+      #
+      #     def current_user
+      #     end
+      #   end
+      #
+      class ResourcefulActions < Base
+        MSG = "`%<name>s` is not one of the seven resourceful actions (index, " \
+              "show, new, edit, create, update, destroy) — rename it, extract " \
+              "another controller, or make it private if it isn't an action. " \
+              "See https://thoughtbot.com/blog/in-relentless-pursuit-of-rest-ish-routing"
+
+        RESOURCEFUL_ACTIONS = %i[index show new edit create update destroy].freeze
+        VISIBILITY_MODIFIERS = %i[public protected private].freeze
+
+        def on_class(node)
+          return unless controller?(node)
+          return unless node.body
+
+          non_resourceful_actions(node.body).each do |action|
+            add_offense(action.loc.name, message: format(MSG, name: action.method_name))
+          end
+        end
+
+        private
+
+        def controller?(node)
+          node.identifier.short_name.to_s.end_with?("Controller")
+        end
+
+        def non_resourceful_actions(body)
+          visibility = :public
+          public_defs = []
+          hidden = []
+
+          body_children(body).each do |child|
+            if visibility_modifier?(child)
+              child.arguments.empty? ? visibility = child.method_name : hidden.concat(hidden_names(child))
+            elsif child.def_type? && visibility == :public
+              public_defs << child
+            end
+          end
+
+          public_defs.reject do |definition|
+            RESOURCEFUL_ACTIONS.include?(definition.method_name) || hidden.include?(definition.method_name)
+          end
+        end
+
+        def body_children(body)
+          body.begin_type? ? body.children : [body]
+        end
+
+        def visibility_modifier?(node)
+          node.send_type? && node.receiver.nil? && VISIBILITY_MODIFIERS.include?(node.method_name)
+        end
+
+        # `private :current_user` hides an already-defined method. An inline
+        # `private def foo` passes a `def` rather than a symbol, and never
+        # reaches us as a body child anyway.
+        def hidden_names(node)
+          return [] if node.method?(:public)
+
+          node.arguments.select(&:sym_type?).map(&:value)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/thoughtbot_cops.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative "thoughtbot/no_before"
+require_relative "thoughtbot/no_let"
+require_relative "thoughtbot/resourceful_actions"

data/lib/rubocop/thoughtbot/plugin.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+
+module RuboCop
+  module Thoughtbot
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: "rubocop-thoughtbot",
+          version: VERSION,
+          homepage: "https://github.com/thoughtbot/rubocop-thoughtbot",
+          description: "A RuboCop and Standard plugin based on thoughtbot's accumulated best-practices."
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      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/thoughtbot/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Thoughtbot
+    VERSION = "0.1.0"
+  end
+end

data/lib/rubocop/thoughtbot.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "thoughtbot/version"
+
+module RuboCop
+  module Thoughtbot
+    class Error < StandardError; end
+    # Your code goes here...
+  end
+end

data/lib/rubocop-thoughtbot.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "rubocop/thoughtbot"
+require_relative "rubocop/thoughtbot/version"
+require_relative "rubocop/thoughtbot/plugin"
+
+require_relative "rubocop/cop/thoughtbot_cops"

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-thoughtbot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jared Turner
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !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
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.72.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.72.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '2'
+description: A RuboCop Plugin based on thoughtbot's accumulated best-practices.
+email:
+- jared.turner@thoughtbot.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".tool-versions"
+- BELIEFS.md
+- CHANGELOG.md
+- CODEOWNERS
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/default.yml
+- docs/modules/ROOT/pages/cops.adoc
+- docs/modules/ROOT/pages/cops_thoughtbot.adoc
+- lib/rubocop-thoughtbot.rb
+- lib/rubocop/cop/thoughtbot/no_before.rb
+- lib/rubocop/cop/thoughtbot/no_let.rb
+- lib/rubocop/cop/thoughtbot/resourceful_actions.rb
+- lib/rubocop/cop/thoughtbot_cops.rb
+- lib/rubocop/thoughtbot.rb
+- lib/rubocop/thoughtbot/plugin.rb
+- lib/rubocop/thoughtbot/version.rb
+homepage: http://github.com/thoughtbot/rubocop-thoughtbot
+licenses:
+- MIT
+metadata:
+  homepage_uri: http://github.com/thoughtbot/rubocop-thoughtbot
+  source_code_uri: http://github.com/thoughtbot/rubocop-thoughtbot
+  changelog_uri: http://github.com/thoughtbot/rubocop-thoughtbot/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+  default_lint_roller_plugin: RuboCop::Thoughtbot::Plugin
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: A RuboCop Plugin based on thoughtbot's accumulated best-practices.
+test_files: []