rubocop-factory_bot 2.22.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 44482485fe839223a23464d6739cbd0160ebaffa5402c9057d2fdc0e3c9b3295
+  data.tar.gz: 035ac59bb998b1268bf0803bce35b9c2ab75ac6f232a427e28996f0ea857f386
+SHA512:
+  metadata.gz: fd92b4d37f8a352e1acc98ae2bbbad05982248d3ef97dfb6b99edfe5173ba087a4259db3718e1e05c0b7951574652b657b694d2f02a5c34cf162d17fe427303a
+  data.tar.gz: 10cf9b7446c6fbd09a2ffcfe8629be12c2dc334132d6515acd8015b0f22a7e06e01d704f42316730e096901889f189adcaff8730571df86e401e7767688c07f3

data/CHANGELOG.md

@@ -0,0 +1,69 @@
+# Changelog
+
+## Master (Unreleased)
+
+## 2.22.0 (2023-05-04)
+
+- Extracted from `rubocop-rspec` into a separate repository for easier use with Minitest/Cucumber. ([@ydah])
+
+## Previously (see [rubocop-rspec's changelist](https://github.com/rubocop/rubocop-rspec/blob/70a97b1895ce4b9bcd6ff336d5d343ddc6175fe6/CHANGELOG.md) for details)
+
+- Fix a false positive for `RSpec/FactoryBot/ConsistentParenthesesStyle` inside `&&`, `||` and `:?` when `omit_parentheses` is on ([@dmitrytsepelev])
+- Add new `RSpec/FactoryBot/FactoryNameStyle` cop. ([@ydah])
+- Fix wrong autocorrection in `n_times` style on `RSpec/FactoryBot/CreateList`. ([@r7kamura])
+- Fix a false positive for `RSpec/FactoryBot/ConsistentParenthesesStyle` when using `generate` with multiple arguments. ([@ydah])
+- Fix `RSpec/FactoryBot/ConsistentParenthesesStyle` to ignore calls without the first positional argument. ([@pirj])
+- Fix `RSpec/FactoryBot/ConsistentParenthesesStyle` to ignore calls inside a Hash or an Array. ([@pirj])
+- Fix an incorrect autocorrect for `FactoryBot/ConsistentParenthesesStyle` with `omit_parentheses` option when method name and first argument are not on same line. ([@ydah])
+- Add `RSpec/FactoryBot/ConsistentParenthesesStyle` cop. ([@Liberatys])
+- Support `Array.new(n)` on `RSpec/FactoryBot/CreateList` cop. ([@r7kamura])
+- Fixed false offense detection in `FactoryBot/CreateList` when a n.times block is including method calls in the factory create arguments. ([@ngouy])
+- Fix error in `RSpec/RSpec/FactoryBot/CreateList` cop for empty block. ([@tejasbubane])
+- Fix `RSpec/FactoryBot/SyntaxMethods` and `RSpec/Capybara/FeatureMethods` to inspect shared groups. ([@pirj])
+- Add new `RSpec/FactoryBot/SyntaxMethods` cop. ([@leoarnold])
+- Change namespace of several cops (`Capybara/*` -> `RSpec/Capybara/*`, `FactoryBot/*` -> `RSpec/FactoryBot/*`, `Rails/*` -> `RSpec/Rails/*`). ([@pirj], [@bquorning])
+- Fix `FactoryBot/AttributeDefinedStatically` to allow `#traits_for_enum` without a block. ([@harrylewis])
+- Improve the performance of `FactoryBot/AttributeDefinedStatically`, `RSpec/InstanceVariable`, `RSpec/LetSetup`, `RSpec/NestedGroups` and `RSpec/ReturnFromStub`. ([@andrykonchin])
+- Improve message and description of `FactoryBot/FactoryClassName`. ([@ybiquitous])
+- Fix `FactoryBot/FactoryClassName` to ignore `Hash` and `OpenStruct`. ([@jfragoulis])
+- Add `FactoryBot/FactoryClassName` cop. ([@jfragoulis])
+- Fix `FactoryBot/AttributeDefinedStatically` not working with an explicit receiver. ([@composerinteralia])
+- Fix `FactoryBot/CreateList` autocorrect crashing when the factory is called with a block=. ([@Darhazer])
+- `FactoryBot/CreateList` now ignores `times` blocks with an argument. ([@Darhazer])
+- Fix `FactoryBot/AttributeDefinedStatically` not working when there is a non-symbol key. ([@vzvu3k6k])
+- Fix false negative in `FactoryBot/AttributeDefinedStatically` when attribute is defined on `self`. ([@Darhazer])
+- `RSpec/FactoryBot` cops will now also inspect the `spec/factories.rb` path by default. ([@bquorning])
+- Add `FactoryBot/AttributeDefinedStatically` cop to help FactoryBot users with the deprecation of static attributes. ([@composerinteralia], [@seanpdoyle])
+- Remove `FactoryBot/DynamicAttributeDefinedStatically` and `FactoryBot/StaticAttributeDefinedDynamically` cops. ([@composerinteralia])
+- Fix `FactoryBot/DynamicAttributeDefinedStatically` false positive when using symbol proc argument for a sequence. ([@tdeo])
+- Add `FactoryBot/CreateList` cop. ([@Darhazer])
+- Fix `FactoryBot/StaticAttributeDefinedDynamically` to handle empty block. ([@abrom])
+- Fix false positive in `FactoryBot/DynamicAttributeDefinedStatically` when a before/after callback has a symbol proc argument. ([@abrom])
+- Fix `FactoryBot/DynamicAttributeDefinedStatically` to handle dynamic attributes inside arrays/hashes. ([@abrom])
+- Add `FactoryBot/StaticAttributeDefinedDynamically` (based on dynamic attribute cop). ([@abrom])
+- Rename namespace `FactoryGirl` to `FactoryBot` following original library update. ([@walf443])
+- Add `RSpec/FactoryGirl` namespace including the first cop for factories: `FactoryGirl/DynamicAttributeDefinedStatically`. ([@jonatas])
+
+<!-- Contributors (alphabetically) -->
+
+[@abrom]: https://github.com/abrom
+[@andrykonchin]: https://github.com/andrykonchin
+[@bquorning]: https://github.com/bquorning
+[@composerinteralia]: https://github.com/composerinteralia
+[@darhazer]: https://github.com/Darhazer
+[@dmitrytsepelev]: https://github.com/dmitrytsepelev
+[@harrylewis]: https://github.com/harrylewis
+[@jfragoulis]: https://github.com/jfragoulis
+[@jonatas]: https://github.com/jonatas
+[@leoarnold]: https://github.com/leoarnold
+[@liberatys]: https://github.com/Liberatys
+[@ngouy]: https://github.com/ngouy
+[@pirj]: https://github.com/pirj
+[@r7kamura]: https://github.com/r7kamura
+[@seanpdoyle]: https://github.com/seanpdoyle
+[@tdeo]: https://github.com/tdeo
+[@tejasbubane]: https://github.com/tejasbubane
+[@vzvu3k6k]: https://github.com/vzvu3k6k
+[@walf443]: https://github.com/walf443
+[@ybiquitous]: https://github.com/ybiquitous
+[@ydah]: https://github.com/ydah

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,17 @@
+# The RuboCop Community Code of Conduct
+
+**Note:** We have picked the following code of conduct based on [Ruby's own
+code of conduct](https://www.ruby-lang.org/en/conduct/).
+
+This document provides a few simple community guidelines for a safe, respectful,
+productive, and collaborative place for any person who is willing to contribute
+to the RuboCop community. It applies to all "collaborative spaces", which are
+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.

data/MIT-LICENSE.md

@@ -0,0 +1,21 @@
+# The MIT License (MIT)
+
+Copyright (c) 2014 Ian MacLeod <ian@nevir.net>
+
+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,88 @@
+# RuboCop factory_bot
+
+[![Join the chat at https://gitter.im/rubocop-rspec/Lobby](https://badges.gitter.im/rubocop-rspec/Lobby.svg)](https://gitter.im/rubocop-rspec/Lobby)
+[![Gem Version](https://badge.fury.io/rb/rubocop-factory_bot.svg)](https://rubygems.org/gems/rubocop-factory_bot)
+![CI](https://github.com/rubocop/rubocop-factory_bot/workflows/CI/badge.svg)
+
+[Factory Bot](https://www.rubydoc.info/gems/factory_bot)-specific analysis for your projects, as an extension to
+[RuboCop](https://github.com/rubocop/rubocop).
+
+## Installation
+
+Just install the `rubocop-factory_bot` gem
+
+```bash
+gem install rubocop-factory_bot
+```
+
+or if you use bundler put this in your `Gemfile`
+
+```
+gem 'rubocop-factory_bot', require: false
+```
+
+## Usage
+
+You need to tell RuboCop to load the Factory Bot extension. There are three
+ways to do this:
+
+### RuboCop configuration file
+
+Put this into your `.rubocop.yml`.
+
+```yaml
+require: rubocop-factory_bot
+```
+
+Alternatively, use the following array notation when specifying multiple extensions.
+
+```yaml
+require:
+  - rubocop-other-extension
+  - rubocop-factory_bot
+```
+
+Now you can run `rubocop` and it will automatically load the RuboCop factory_bot
+cops together with the standard cops.
+
+### Command line
+
+```bash
+rubocop --require rubocop-factory_bot
+```
+
+### Rake task
+
+```ruby
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-factory_bot'
+end
+```
+
+## Documentation
+
+You can read more about RuboCop factory_bot in its [official manual](https://docs.rubocop.org/rubocop-factory_bot).
+
+## The Cops
+
+All cops are located under
+[`lib/rubocop/cop/factory_bot`](lib/rubocop/cop/factory_bot), and contain
+examples/documentation.
+
+In your `.rubocop.yml`, you may treat the Factory Bot cops just like any other
+cop. For example:
+
+```yaml
+FactoryBot/AttributeDefinedStatically:
+  Exclude:
+    - spec/factories/my_factory.rb
+```
+
+## Contributing
+
+Checkout the [contribution guidelines](.github/CONTRIBUTING.md).
+
+## License
+
+`rubocop-factory_bot` is MIT licensed. [See the accompanying file](MIT-LICENSE.md) for
+the full text.

data/config/default.yml

@@ -0,0 +1,75 @@
+---
+FactoryBot:
+  Enabled: true
+  Include:
+    - "**/*_spec.rb"
+    - "**/spec/**/*"
+    - "**/test/**/*"
+    - "**/features/support/factories/**/*.rb"
+  DocumentationBaseURL: https://docs.rubocop.org/rubocop-factory_bot
+
+FactoryBot/AttributeDefinedStatically:
+  Description: Always declare attribute values as blocks.
+  Enabled: true
+  Include:
+    - spec/factories.rb
+    - spec/factories/**/*.rb
+    - features/support/factories/**/*.rb
+  VersionAdded: '1.28'
+  VersionChanged: '2.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/AttributeDefinedStatically
+
+FactoryBot/ConsistentParenthesesStyle:
+  Description: Use a consistent style for parentheses in factory bot calls.
+  Enabled: pending
+  EnforcedStyle: require_parentheses
+  SupportedStyles:
+    - require_parentheses
+    - omit_parentheses
+  VersionAdded: '2.14'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/ConsistentParenthesesStyle
+
+FactoryBot/CreateList:
+  Description: Checks for create_list usage.
+  Enabled: true
+  Include:
+    - "**/*_spec.rb"
+    - "**/spec/**/*"
+    - spec/factories.rb
+    - spec/factories/**/*.rb
+    - features/support/factories/**/*.rb
+  EnforcedStyle: create_list
+  SupportedStyles:
+    - create_list
+    - n_times
+  VersionAdded: '1.25'
+  VersionChanged: '2.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/CreateList
+
+FactoryBot/FactoryClassName:
+  Description: Use string value when setting the class attribute explicitly.
+  Enabled: true
+  Include:
+    - spec/factories.rb
+    - spec/factories/**/*.rb
+    - features/support/factories/**/*.rb
+  VersionAdded: '1.37'
+  VersionChanged: '2.0'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/FactoryClassName
+
+FactoryBot/FactoryNameStyle:
+  Description: Checks for name style for argument of FactoryBot::Syntax::Methods.
+  Enabled: pending
+  VersionAdded: '2.16'
+  EnforcedStyle: symbol
+  SupportedStyles:
+    - symbol
+    - string
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/FactoryNameStyle
+
+FactoryBot/SyntaxMethods:
+  Description: Use shorthands from `FactoryBot::Syntax::Methods` in your specs.
+  Enabled: pending
+  SafeAutoCorrect: false
+  VersionAdded: '2.7'
+  Reference: https://www.rubydoc.info/gems/rubocop-factory_bot/RuboCop/Cop/FactoryBot/SyntaxMethods

data/lib/rubocop/cop/factory_bot/attribute_defined_statically.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Always declare attribute values as blocks.
+      #
+      # @example
+      #   # bad
+      #   kind [:active, :rejected].sample
+      #
+      #   # good
+      #   kind { [:active, :rejected].sample }
+      #
+      #   # bad
+      #   closed_at 1.day.from_now
+      #
+      #   # good
+      #   closed_at { 1.day.from_now }
+      #
+      #   # bad
+      #   count 1
+      #
+      #   # good
+      #   count { 1 }
+      #
+      class AttributeDefinedStatically < ::RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = 'Use a block to declare attribute values.'
+
+        # @!method value_matcher(node)
+        def_node_matcher :value_matcher, <<-PATTERN
+            (send _ !#reserved_method? $...)
+        PATTERN
+
+        # @!method factory_attributes(node)
+        def_node_matcher :factory_attributes, <<-PATTERN
+            (block (send _ #attribute_defining_method? ...) _ { (begin $...) $(send ...) } )
+        PATTERN
+
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
+          attributes = factory_attributes(node) || []
+          attributes = [attributes] unless attributes.is_a?(Array) # rubocop:disable Style/ArrayCoercion, Lint/RedundantCopDisableDirective
+
+          attributes.each do |attribute|
+            next unless offensive_receiver?(attribute.receiver, node)
+            next if proc?(attribute) || association?(attribute.first_argument)
+
+            add_offense(attribute) do |corrector|
+              autocorrect(corrector, attribute)
+            end
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          if node.parenthesized?
+            autocorrect_replacing_parens(corrector, node)
+          else
+            autocorrect_without_parens(corrector, node)
+          end
+        end
+
+        def offensive_receiver?(receiver, node)
+          receiver.nil? ||
+            receiver.self_type? ||
+            receiver_matches_first_block_argument?(receiver, node)
+        end
+
+        def receiver_matches_first_block_argument?(receiver, node)
+          first_block_argument = node.arguments.first
+
+          !first_block_argument.nil? &&
+            receiver.lvar_type? &&
+            receiver.node_parts == first_block_argument.node_parts
+        end
+
+        def proc?(attribute)
+          value_matcher(attribute).to_a.all?(&:block_pass_type?)
+        end
+
+        # @!method association?(node)
+        def_node_matcher :association?, '(hash <(pair (sym :factory) _) ...>)'
+
+        def autocorrect_replacing_parens(corrector, node)
+          left_braces, right_braces = braces(node)
+
+          corrector.replace(node.location.begin, " #{left_braces}")
+          corrector.replace(node.location.end, right_braces)
+        end
+
+        def autocorrect_without_parens(corrector, node)
+          left_braces, right_braces = braces(node)
+
+          argument = node.first_argument
+          expression = argument.source_range
+          corrector.insert_before(expression, left_braces)
+          corrector.insert_after(expression, right_braces)
+        end
+
+        def braces(node)
+          if value_hash_without_braces?(node.first_argument)
+            ['{ { ', ' } }']
+          else
+            ['{ ', ' }']
+          end
+        end
+
+        def value_hash_without_braces?(node)
+          node.hash_type? && !node.braces?
+        end
+
+        def reserved_method?(method_name)
+          RuboCop::FactoryBot.reserved_methods.include?(method_name)
+        end
+
+        def attribute_defining_method?(method_name)
+          RuboCop::FactoryBot.attribute_defining_methods
+            .include?(method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/factory_bot/consistent_parentheses_style.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module FactoryBot
+      # Use a consistent style for parentheses in factory bot calls.
+      #
+      # @example
+      #
+      #   # bad
+      #   create :user
+      #   build(:user)
+      #   create(:login)
+      #   create :login
+      #
+      # @example `EnforcedStyle: require_parentheses` (default)
+      #
+      #   # good
+      #   create(:user)
+      #   create(:user)
+      #   create(:login)
+      #   build(:login)
+      #
+      # @example `EnforcedStyle: omit_parentheses`
+      #
+      #   # good
+      #   create :user
+      #   build :user
+      #   create :login
+      #   create :login
+      #
+      #   # also good
+      #   # when method name and first argument are not on same line
+      #   create(
+      #     :user
+      #   )
+      #   build(
+      #     :user,
+      #     name: 'foo'
+      #   )
+      #
+      class ConsistentParenthesesStyle < ::RuboCop::Cop::Base
+        extend AutoCorrector
+        include ConfigurableEnforcedStyle
+        include RuboCop::FactoryBot::Language
+        include RuboCop::Cop::Util
+
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
+        MSG_REQUIRE_PARENS = 'Prefer method call with parentheses'
+        MSG_OMIT_PARENS = 'Prefer method call without parentheses'
+
+        FACTORY_CALLS = RuboCop::FactoryBot::Language::METHODS
+
+        RESTRICT_ON_SEND = FACTORY_CALLS
+
+        # @!method factory_call(node)
+        def_node_matcher :factory_call, <<-PATTERN
+            (send
+              {#factory_bot? nil?} %FACTORY_CALLS
+              {sym str send lvar} _*
+            )
+        PATTERN
+
+        def on_send(node)
+          return if ambiguous_without_parentheses?(node)
+
+          factory_call(node) do
+            return if node.method?(:generate) && node.arguments.count > 1
+
+            if node.parenthesized?
+              process_with_parentheses(node)
+            else
+              process_without_parentheses(node)
+            end
+          end
+        end
+
+        private
+
+        def process_with_parentheses(node)
+          return unless style == :omit_parentheses
+          return unless same_line?(node, node.first_argument)
+
+          add_offense(node.loc.selector,
+                      message: MSG_OMIT_PARENS) do |corrector|
+            remove_parentheses(corrector, node)
+          end
+        end
+
+        def process_without_parentheses(node)
+          return unless style == :require_parentheses
+
+          add_offense(node.loc.selector,
+                      message: MSG_REQUIRE_PARENS) do |corrector|
+            add_parentheses(node, corrector)
+          end
+        end
+
+        AMBIGUOUS_TYPES = %i[send pair array and or if].freeze
+
+        def ambiguous_without_parentheses?(node)
+          node.parent && AMBIGUOUS_TYPES.include?(node.parent.type)
+        end
+
+        def remove_parentheses(corrector, node)
+          corrector.replace(node.location.begin, ' ')
+          corrector.remove(node.location.end)
+        end
+      end
+    end
+  end
+end