rubocop-prefer_it_parameter 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5cc86f9725bb1e055df24642820dd33b8f6783b9a8b493f9ee4b8fbb74672107
+  data.tar.gz: d6baada0d759d55b85a28966463ebb479d4db86aeaebe4cd09ea5bfeca4b9310
+SHA512:
+  metadata.gz: d5828d52ff9ecf241a7c27f8b623ce4b7c479492c96c0600c992bb39eb5620a9b65c2a6914d1bf4aeaae0451295a4961a1105bc5af8c1f05f2a731b51e30970b
+  data.tar.gz: afd728b9c7367f1e4af45a695169fa3fd07fb1b52ca6ab855c56af99e09bacc312f1074458ba580befa36a8b769e5a170badf166ba0763ddd41538974825cf40

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+## [Unreleased]
+
+## [1.0.0] - 2026-08-05
+
+Initial release.
+
+- `Style/PreferItParameter`: recommends the `it` block parameter (Ruby 3.4+) over a named
+  block argument in single-line blocks. Autocorrection is available but unsafe, so
+  `rubocop -A` is required to apply it. Only projects with `TargetRubyVersion` 3.4 or
+  higher are inspected; see the README for the cases the cop skips.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"rubocop-prefer_it_parameter" 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 ["i.tkomiya@gmail.com"](mailto:"i.tkomiya@gmail.com").

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Takeshi KOMIYA
+
+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,136 @@
+# rubocop-prefer_it_parameter
+
+A RuboCop plugin that recommends using the `it` block parameter (Ruby 3.4+) instead of named block arguments in single-line blocks.
+
+## Installation
+
+Add the gem to your application's Gemfile. RuboCop loads it through `plugins:`, so it does not need to be required:
+
+```ruby
+group :development do
+  gem "rubocop-prefer_it_parameter", require: false
+end
+```
+
+Or install it directly:
+
+```bash
+gem install rubocop-prefer_it_parameter
+```
+
+Then add it to your `.rubocop.yml`:
+
+```yaml
+plugins:
+  - rubocop-prefer_it_parameter
+```
+
+## Cops
+
+### Style/PreferItParameter
+
+Prefer the `it` block parameter over a named block argument in single-line blocks. Only blocks consisting of a single statement are converted. This cop supports autocorrection.
+
+**Bad:**
+
+```ruby
+users.map { |user| user.name.upcase }
+items.select { |item| item.active? && item.visible? }
+```
+
+**Good:**
+
+```ruby
+users.map { it.name.upcase }
+items.select { it.active? && it.visible? }
+```
+
+A value omission is spelled out, since `{it:}` would call a method named `it`:
+
+```ruby
+# bad
+items.map { |item| {item:} }
+
+# good
+items.map { {item: it} }
+```
+
+The autocorrection is marked unsafe — see [Safety](#safety).
+
+#### Exceptions
+
+A block is left alone when it:
+
+- is multi-line — a named argument reads better there
+- has two or more statements
+- contains a nested block — only the innermost block is converted
+- takes anything other than a single plain argument, including a trailing comma such as `|x,|` (which destructures the yielded value while `it` does not)
+- rebinds its argument, by assignment or by pattern matching
+- never references its argument (see `Lint/UnusedBlockArgument`)
+- references a local variable named `it` from an enclosing scope, or assigns to `it`
+- already names its argument `it` — dropping it would revive an `it` from an enclosing scope (`Style/ItAssignment` forbids the name instead)
+- defines a callable or a method — `->(x) { }`, `lambda`, `proc`, `Proc.new`, `define_method`, `define_singleton_method` — since the parameter list is part of its API and `it` drops the parameter name
+
+## Related cops
+
+### `Style/ItBlockParameter` (RuboCop core)
+
+It ships as `Enabled: pending`, so it needs `NewCops: enable` or an explicit `Enabled: true`. Once enabled, the two cops do not conflict — they cover different cells of the same grid:
+
+| | `Style/PreferItParameter` (this gem) | `Style/ItBlockParameter` (core, `allow_single_line`) |
+|---|---|---|
+| single-line block with a named argument | offense | — |
+| single-line block using `_1` | — | offense |
+| multi-line block using `_1` | — | offense |
+| multi-line block using `it` | — | offense |
+| multi-line block with a named argument | — | — |
+
+Enabling both enforces "use `it` for single-line blocks, use a named argument for multi-line blocks" consistently.
+
+Do not set core's cop to `EnforcedStyle: always` — it then checks named block arguments as well, and the two autocorrections collide on the same block.
+
+### `Style/ItAssignment` (RuboCop core) — recommended
+
+```yaml
+Style/ItAssignment:
+  Enabled: true
+```
+
+`Style/ItAssignment` forbids naming a local variable or parameter `it`, which `Style/PreferItParameter` cannot fully guard against on its own — see [Safety](#safety).
+
+## Safety
+
+The autocorrection is marked unsafe (`SafeAutoCorrect: false`), so `rubocop -a` reports the offenses without changing anything and `rubocop -A` is needed to apply them. `it` is not equivalent to a named argument in every respect:
+
+- A local variable or parameter named `it` takes precedence over the block parameter. The cop skips a block that references such a variable, but it cannot detect one that the block never references — there the autocorrection silently changes what the block sees. Enabling `Style/ItAssignment` is therefore a prerequisite.
+- `Proc#parameters` loses the argument name: `[[:opt, :x]]` becomes `[[:opt]]`. Blocks that define a callable or a method are excluded for this reason, but a block captured with `&block` and introspected elsewhere is still affected.
+- `binding.local_variable_get(:x)` inside the block stops working.
+
+## Requirements
+
+- Ruby >= 3.4
+- RuboCop >= 1.75.0
+
+The cop only inspects projects whose `TargetRubyVersion` is 3.4 or higher, since that is when `it` was introduced.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rake` to run the whole check suite (RuboCop, RSpec, Steep and RBS validation), or `bundle exec rake spec` for the tests alone. 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`.
+
+## Releasing
+
+Bump `VERSION` in `lib/rubocop/prefer_it_parameter/version.rb`, add an entry to [CHANGELOG.md](CHANGELOG.md), and merge that into `main`. The [release workflow](.github/workflows/release.yml) picks up the change to `version.rb`, tags the version, and pushes the gem to [rubygems.org](https://rubygems.org) through trusted publishing. It can also be started by hand from the Actions tab.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/tk0miya/rubocop-prefer_it_parameter. 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/tk0miya/rubocop-prefer_it_parameter/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-prefer_it_parameter project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/tk0miya/rubocop-prefer_it_parameter/blob/main/CODE_OF_CONDUCT.md).

data/config/default.yml

@@ -0,0 +1,6 @@
+Style/PreferItParameter:
+  Description: 'Prefer the `it` block parameter over a named block argument in single-line blocks.'
+  Reference: https://github.com/tk0miya/rubocop-prefer_it_parameter#stylepreferitparameter
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '1.0'

data/lib/rubocop/cop/style/prefer_it_parameter.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer the `it` block parameter over a named block argument in single-line blocks.
+      #
+      # Only blocks consisting of a single statement are converted. This cop complements
+      # `Style/ItBlockParameter` in RuboCop core, which converts `_1` to `it` but in its
+      # default style does not check named block arguments.
+      #
+      # @safety
+      #   The autocorrection is unsafe because a local variable named `it` that the
+      #   block does not reference cannot be detected, and replacing it would silently
+      #   change what the block sees. Enabling `Style/ItAssignment` rules such names
+      #   out. Additionally, `it` drops the argument name from `Proc#parameters`
+      #   (`[[:opt, :x]]` becomes `[[:opt]]`) and breaks
+      #   `binding.local_variable_get(:x)` inside the block. Blocks that define a
+      #   callable or a method are skipped for that reason, but a block captured with
+      #   `&block` and introspected elsewhere is still affected.
+      #
+      # @example
+      #   # bad
+      #   users.map { |user| user.name.upcase }
+      #   items.select { |item| item.active? && item.visible? }
+      #
+      #   # good
+      #   users.map { it.name.upcase }
+      #   items.select { it.active? && it.visible? }
+      #
+      #   # good - multi-line block
+      #   users.each do |user|
+      #     user.activate!
+      #     notify(user)
+      #   end
+      #
+      #   # good - the block consists of two statements
+      #   items.each { |item| validate(item); save(item) }
+      #
+      #   # good - only the innermost block may use `it`
+      #   matrix.map { |row| row.map { it * 2 } }
+      #
+      #   # good - `|x,|` destructures the yielded value, unlike `it`
+      #   pairs.each { |pair,| puts pair }
+      #
+      #   # good - a callable's parameter list is part of its API
+      #   ->(x) { puts x }
+      #   define_method(:m) { |x| x + 1 }
+      #
+      #   # bad
+      #   items.map { |item| {item:} }
+      #
+      #   # good - the value is spelled out, since `{it:}` would call a method named `it`
+      #   items.map { {item: it} }
+      #
+      class PreferItParameter < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+        include RangeHelp
+
+        minimum_target_ruby_version 3.4
+
+        MSG = "Use the `it` block parameter instead of the named block argument `%<name>s`."
+
+        INNER_BLOCK_TYPES = %i[block numblock itblock].freeze #: Array[Symbol]
+
+        CALLABLE_METHODS = %i[define_method define_singleton_method lambda proc].freeze #: Array[Symbol]
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def on_block(node) #: void
+          body = node.body
+          return unless body
+
+          name = convertible_argument_name(node, body)
+          return unless name
+
+          references = lvar_references(body, name)
+          return if references.empty?
+
+          register_offense(node, name, references)
+        end
+
+        private
+
+        # @rbs node: RuboCop::AST::BlockNode
+        # @rbs body: RuboCop::AST::Node
+        def convertible_argument_name(node, body) #: Symbol?
+          return unless node.single_line?
+          return if defines_callable?(node)
+
+          name = sole_argument_name(node)
+          return unless name
+          return unless convertible_body?(body, name)
+          return if shadows_it?(body)
+
+          name
+        end
+
+        # `it` would not mean what the block expects when a local variable named `it`
+        # is already in scope, or when the body assigns to `it` — assigning turns `it`
+        # into a plain local variable and disables the implicit block parameter.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def shadows_it?(body) #: bool
+          lvar_references(body, :it).any? || reassigned?(body, :it)
+        end
+
+        # `it` drops the parameter name from `Proc#parameters`, which changes the
+        # meaning of a block that defines a callable object or a method: there the
+        # parameter list is part of the API, unlike a block passed to `each` or `map`.
+        #
+        # @rbs node: RuboCop::AST::BlockNode
+        def defines_callable?(node) #: bool
+          CALLABLE_METHODS.include?(node.method_name) || proc_new?(node)
+        end
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def proc_new?(node) #: bool
+          return false unless node.method?(:new)
+
+          receiver = node.send_node.receiver
+          return false unless receiver&.const_type?
+
+          const = receiver #: RuboCop::AST::ConstNode
+          const.short_name == :Proc
+        end
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def sole_argument_name(node) #: Symbol?
+          return unless node.argument_list.one?
+
+          argument = node.first_argument
+          # Rules out optarg, restarg, kwarg, blockarg, shadowarg and mlhs at once.
+          return unless argument&.arg_type?
+          # `|x,|` is indistinguishable from `|x|` in the AST even though it
+          # destructures the yielded value, so the source has to be checked.
+          return if node.arguments.source&.include?(",")
+
+          plain_argument = argument #: RuboCop::AST::ArgNode
+          plain_argument.name
+        end
+
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def convertible_body?(body, name) #: bool
+          single_statement?(body) && !contains_block?(body) && !reassigned?(body, name)
+        end
+
+        # `begin` (parentheses) and `kwbegin` (`begin ... end`) both wrap a sequence of
+        # statements as well as a single expression, so the number of children is what
+        # tells the two apart.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def single_statement?(body) #: bool
+          return body.each_child_node.one? if body.type?(:begin, :kwbegin)
+
+          true
+        end
+
+        # `it` is a syntax error inside a block that has an ordinary parameter, and
+        # silently shadows the outer one inside a parameterless block, so only the
+        # innermost block is converted.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def contains_block?(body) #: bool
+          body.each_node(*INNER_BLOCK_TYPES).any?
+        end
+
+        # A block that rebinds the name cannot be converted: the value `it` refers to
+        # would no longer be the one the block was yielded. `match_var` covers pattern
+        # matching (`1 in x`), which rebinds just like an assignment.
+        #
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def reassigned?(body, name) #: bool
+          body.each_node(:lvasgn, :match_var).any? do |node|
+            node.to_a.first == name
+          end
+        end
+
+        # Returns the enclosing pair when the reference is a value omission (`{x:}`,
+        # `foo(x:)`). Such a reference shares its source range with the label, so the
+        # value has to be written after the pair rather than replaced.
+        #
+        # @rbs reference: RuboCop::AST::Node
+        def omitted_value_pair(reference) #: RuboCop::AST::PairNode?
+          parent = reference.parent
+          return unless parent&.pair_type?
+
+          pair = parent #: RuboCop::AST::PairNode
+          pair if pair.value_omission?
+        end
+
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def lvar_references(body, name) #: Array[RuboCop::AST::Node]
+          body.each_node(:lvar).select do |node|
+            variable = node #: RuboCop::AST::VarNode
+            variable.name == name
+          end
+        end
+
+        # @rbs node: RuboCop::AST::BlockNode
+        # @rbs name: Symbol
+        # @rbs references: Array[RuboCop::AST::Node]
+        def register_offense(node, name, references) #: void
+          add_offense(node.arguments, message: format(MSG, name:)) do |corrector|
+            references.each do |reference|
+              replace_reference(corrector, reference)
+            end
+            corrector.remove(arguments_removal_range(node))
+          end
+        end
+
+        # @rbs corrector: RuboCop::Cop::Corrector
+        # @rbs reference: RuboCop::AST::Node
+        def replace_reference(corrector, reference) #: void
+          pair = omitted_value_pair(reference)
+          if pair
+            corrector.insert_after(pair.source_range, " it")
+          else
+            corrector.replace(reference.source_range, "it")
+          end
+        end
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def arguments_removal_range(node) #: Parser::Source::Range
+          range_with_surrounding_space(node.arguments.source_range, side: :right, newlines: false)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/prefer_it_parameter/plugin.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lint_roller"
+require "pathname"
+
+require_relative "version"
+
+module RuboCop
+  module PreferItParameter
+    class Plugin < LintRoller::Plugin
+      # @rbs override
+      def about
+        LintRoller::About.new(
+          name: "rubocop-prefer_it_parameter",
+          version: VERSION,
+          homepage: "https://github.com/tk0miya/rubocop-prefer_it_parameter",
+          description: "A RuboCop plugin that recommends using the `it` block parameter " \
+                       "instead of named block arguments in single-line blocks."
+        )
+      end
+
+      # @rbs override
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      # @rbs override
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          # `__dir__` is `String?` in the RBS stubs, so `__FILE__` is used instead.
+          value: Pathname.new(__FILE__).dirname.join("../../../config/default.yml").expand_path
+        )
+      end
+    end
+  end
+end

data/lib/rubocop/prefer_it_parameter/version.rb

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

data/lib/rubocop/prefer_it_parameter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+require_relative "prefer_it_parameter/version"
+require_relative "prefer_it_parameter/plugin"
+require_relative "cop/style/prefer_it_parameter"

data/lib/rubocop-prefer_it_parameter.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "rubocop/prefer_it_parameter"

data/sig/rubocop/cop/style/prefer_it_parameter.rbs

@@ -0,0 +1,148 @@
+# Generated from lib/rubocop/cop/style/prefer_it_parameter.rb with RBS::Inline
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer the `it` block parameter over a named block argument in single-line blocks.
+      #
+      # Only blocks consisting of a single statement are converted. This cop complements
+      # `Style/ItBlockParameter` in RuboCop core, which converts `_1` to `it` but in its
+      # default style does not check named block arguments.
+      #
+      # @safety
+      #   The autocorrection is unsafe because a local variable named `it` that the
+      #   block does not reference cannot be detected, and replacing it would silently
+      #   change what the block sees. Enabling `Style/ItAssignment` rules such names
+      #   out. Additionally, `it` drops the argument name from `Proc#parameters`
+      #   (`[[:opt, :x]]` becomes `[[:opt]]`) and breaks
+      #   `binding.local_variable_get(:x)` inside the block. Blocks that define a
+      #   callable or a method are skipped for that reason, but a block captured with
+      #   `&block` and introspected elsewhere is still affected.
+      #
+      # @example
+      #   # bad
+      #   users.map { |user| user.name.upcase }
+      #   items.select { |item| item.active? && item.visible? }
+      #
+      #   # good
+      #   users.map { it.name.upcase }
+      #   items.select { it.active? && it.visible? }
+      #
+      #   # good - multi-line block
+      #   users.each do |user|
+      #     user.activate!
+      #     notify(user)
+      #   end
+      #
+      #   # good - the block consists of two statements
+      #   items.each { |item| validate(item); save(item) }
+      #
+      #   # good - only the innermost block may use `it`
+      #   matrix.map { |row| row.map { it * 2 } }
+      #
+      #   # good - `|x,|` destructures the yielded value, unlike `it`
+      #   pairs.each { |pair,| puts pair }
+      #
+      #   # good - a callable's parameter list is part of its API
+      #   ->(x) { puts x }
+      #   define_method(:m) { |x| x + 1 }
+      #
+      #   # bad
+      #   items.map { |item| {item:} }
+      #
+      #   # good - the value is spelled out, since `{it:}` would call a method named `it`
+      #   items.map { {item: it} }
+      class PreferItParameter < Base
+        extend AutoCorrector
+
+        extend TargetRubyVersion
+
+        include RangeHelp
+
+        MSG: ::String
+
+        INNER_BLOCK_TYPES: Array[Symbol]
+
+        CALLABLE_METHODS: Array[Symbol]
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def on_block: (RuboCop::AST::BlockNode node) -> void
+
+        private
+
+        # @rbs node: RuboCop::AST::BlockNode
+        # @rbs body: RuboCop::AST::Node
+        def convertible_argument_name: (RuboCop::AST::BlockNode node, RuboCop::AST::Node body) -> Symbol?
+
+        # `it` would not mean what the block expects when a local variable named `it`
+        # is already in scope, or when the body assigns to `it` — assigning turns `it`
+        # into a plain local variable and disables the implicit block parameter.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def shadows_it?: (RuboCop::AST::Node body) -> bool
+
+        # `it` drops the parameter name from `Proc#parameters`, which changes the
+        # meaning of a block that defines a callable object or a method: there the
+        # parameter list is part of the API, unlike a block passed to `each` or `map`.
+        #
+        # @rbs node: RuboCop::AST::BlockNode
+        def defines_callable?: (RuboCop::AST::BlockNode node) -> bool
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def proc_new?: (RuboCop::AST::BlockNode node) -> bool
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def sole_argument_name: (RuboCop::AST::BlockNode node) -> Symbol?
+
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def convertible_body?: (RuboCop::AST::Node body, Symbol name) -> bool
+
+        # `begin` (parentheses) and `kwbegin` (`begin ... end`) both wrap a sequence of
+        # statements as well as a single expression, so the number of children is what
+        # tells the two apart.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def single_statement?: (RuboCop::AST::Node body) -> bool
+
+        # `it` is a syntax error inside a block that has an ordinary parameter, and
+        # silently shadows the outer one inside a parameterless block, so only the
+        # innermost block is converted.
+        #
+        # @rbs body: RuboCop::AST::Node
+        def contains_block?: (RuboCop::AST::Node body) -> bool
+
+        # A block that rebinds the name cannot be converted: the value `it` refers to
+        # would no longer be the one the block was yielded. `match_var` covers pattern
+        # matching (`1 in x`), which rebinds just like an assignment.
+        #
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def reassigned?: (RuboCop::AST::Node body, Symbol name) -> bool
+
+        # Returns the enclosing pair when the reference is a value omission (`{x:}`,
+        # `foo(x:)`). Such a reference shares its source range with the label, so the
+        # value has to be written after the pair rather than replaced.
+        #
+        # @rbs reference: RuboCop::AST::Node
+        def omitted_value_pair: (RuboCop::AST::Node reference) -> RuboCop::AST::PairNode?
+
+        # @rbs body: RuboCop::AST::Node
+        # @rbs name: Symbol
+        def lvar_references: (RuboCop::AST::Node body, Symbol name) -> Array[RuboCop::AST::Node]
+
+        # @rbs node: RuboCop::AST::BlockNode
+        # @rbs name: Symbol
+        # @rbs references: Array[RuboCop::AST::Node]
+        def register_offense: (RuboCop::AST::BlockNode node, Symbol name, Array[RuboCop::AST::Node] references) -> void
+
+        # @rbs corrector: RuboCop::Cop::Corrector
+        # @rbs reference: RuboCop::AST::Node
+        def replace_reference: (RuboCop::Cop::Corrector corrector, RuboCop::AST::Node reference) -> void
+
+        # @rbs node: RuboCop::AST::BlockNode
+        def arguments_removal_range: (RuboCop::AST::BlockNode node) -> Parser::Source::Range
+      end
+    end
+  end
+end

data/sig/rubocop/prefer_it_parameter/plugin.rbs

@@ -0,0 +1,16 @@
+# Generated from lib/rubocop/prefer_it_parameter/plugin.rb with RBS::Inline
+
+module RuboCop
+  module PreferItParameter
+    class Plugin < LintRoller::Plugin
+      # @rbs override
+      def about: ...
+
+      # @rbs override
+      def supported?: ...
+
+      # @rbs override
+      def rules: ...
+    end
+  end
+end

data/sig/rubocop/prefer_it_parameter/version.rbs

@@ -0,0 +1,7 @@
+# Generated from lib/rubocop/prefer_it_parameter/version.rb with RBS::Inline
+
+module RuboCop
+  module PreferItParameter
+    VERSION: ::String
+  end
+end

data/sig/rubocop/prefer_it_parameter.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/rubocop/prefer_it_parameter.rb with RBS::Inline
+

data/sig/rubocop-prefer_it_parameter.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/rubocop-prefer_it_parameter.rb with RBS::Inline
+

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: rubocop-prefer_it_parameter
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Takeshi KOMIYA
+bindir: bin
+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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.75.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.75.0
+description: A RuboCop plugin that recommends using the `it` block parameter instead
+  of named block arguments in single-line blocks.
+email:
+- i.tkomiya@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- LICENSE.txt
+- README.md
+- config/default.yml
+- lib/rubocop-prefer_it_parameter.rb
+- lib/rubocop/cop/style/prefer_it_parameter.rb
+- lib/rubocop/prefer_it_parameter.rb
+- lib/rubocop/prefer_it_parameter/plugin.rb
+- lib/rubocop/prefer_it_parameter/version.rb
+- sig/rubocop-prefer_it_parameter.rbs
+- sig/rubocop/cop/style/prefer_it_parameter.rbs
+- sig/rubocop/prefer_it_parameter.rbs
+- sig/rubocop/prefer_it_parameter/plugin.rbs
+- sig/rubocop/prefer_it_parameter/version.rbs
+homepage: https://github.com/tk0miya/rubocop-prefer_it_parameter
+licenses:
+- MIT
+metadata:
+  default_lint_roller_plugin: RuboCop::PreferItParameter::Plugin
+  source_code_uri: https://github.com/tk0miya/rubocop-prefer_it_parameter
+  changelog_uri: https://github.com/tk0miya/rubocop-prefer_it_parameter/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.4'
+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 that recommends using the `it` block parameter.
+test_files: []