Add new Rails/ContentTag cop #242
Merged
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
andyw8
reviewed
May 2, 2020
koic
reviewed
May 3, 2020
|
Can you add a test case for using block? e.g: content_tag(:div) { content_tag(:strong, 'Hi') } |
koic
reviewed
May 3, 2020
koic
reviewed
May 3, 2020
koic
reviewed
May 3, 2020
tabuchik
changed the title
koic
reviewed
May 4, 2020
koic
reviewed
May 4, 2020
koic
reviewed
May 4, 2020
koic
reviewed
May 4, 2020
|
@koic |
koic
reviewed
May 4, 2020
config/default.yml
Outdated
| - 'https://github.com/rails/rails/issues/25195' | ||
| - 'https://api.rubyonrails.org/classes/ActionView/Helpers/TagHelper.html#method-i-content_tag' | ||
| Enabled: true | ||
| Safe: true |
There was a problem hiding this comment.
Ah, can you omit Safe: true because it is safe by default?
|
This looks good to me. Can you squash your commits into one? |
|
Remove unnecessary |
|
Thank you! |
|
@koic Would you be open to publishing a new release that includes this change (and the other changes since https://github.com/rubocop-hq/rubocop-rails/releases/tag/v2.5.2)? |
|
I've found several issues with this cop and I plan to release 2.6 that includes this one after fixing them. |
|
Gotcha, thank you for the update (and the speedy reply)! |
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 14, 2020
Follow up to rubocop#242. `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
8 tasks
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 16, 2020
Follow up to rubocop#242. This PR allows `content_tag` when the first argument is a variable because `content_tag(name)` is simpler rather than `tag.public_send(name)`. When `public_send` is used, it becomes complicated as follows. First, `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 16, 2020
Follow up to rubocop#242. This PR allows `content_tag` when the first argument is a variable because `content_tag(name)` is simpler rather than `tag.public_send(name)`. When `public_send` is used, it becomes complicated as follows. First, `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 16, 2020
Follow up to rubocop#242. This PR allows `content_tag` when the first argument is a variable because `content_tag(name)` is simpler rather than `tag.public_send(name)`. When `public_send` is used, it becomes complicated as follows. First, `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 16, 2020
Follow up to rubocop#242. This PR allows `content_tag` when the first argument is a variable because `content_tag(name)` is simpler rather than `tag.public_send(name)`. When `public_send` is used, it becomes complicated as follows. First, `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
koic
added a commit
to koic/rubocop-rails
that referenced
this pull request
May 16, 2020
Follow up to rubocop#242. This PR allows `content_tag` when the first argument is a variable because `content_tag(name)` is simpler rather than `tag.public_send(name)`. When `public_send` is used, it becomes complicated as follows. First, `content_tag(name)` cannot be corrected to `tag.name` when the first argument is a variable. So use `public_send` and prevent the following errors in that case: ## Case 1: Using `public_send` to prevent the following `NoMethodError` Original code: ```ruby content_tag(name, 'foo', class: 'bar') ``` Auto-corrected code (before): ```ruby tag(name, 'foo', class: 'bar') #=> NoMethodError (undefined method `each_pair' for "foo":String) ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', class: 'bar') ``` ## Case 2: Using `symbolize_keys` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', {'class' => 'bar'}) ``` Auto-corrected code (before): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', {'class' => 'bar'}.symbolize_keys) ``` The `symbolize_keys` may not be needed, but for safe auto-correction it will be added if optional argument keys are not all symbols. ## Case 3: Using `o ? o.symbolize_keys : {}` to prevent the following `ArgumentError` Original code: ```ruby content_tag(name, 'foo', options) ``` Auto-corrected code (before): When the third argument is `nil`. ```ruby options = nil tag.public_send(name, 'foo', options) #=> `ArgumentError (wrong number of arguments (given 3, expected 1..2))` ``` Auto-corrected code (after): ```ruby tag.public_send(name, 'foo', options ? options.symbolize_keys : {}) ``` Guard with the empty hash in case the third argument is `nil`.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR introduces a cop to check that
tagis used instead ofcontent_tag, becausecontent_tagis legacy syntax.Before submitting the PR make sure the following are checked:
[Fix #issue-number](if the related issue exists).master(if not - rebase it).and description in grammatically correct, complete sentences.
bundle exec rake default. It executes all tests and RuboCop for itself, and generates the documentation.