Diff of the two buildlogs: -- --- b1/build.log 2024-05-15 20:41:16.166840345 +0000 +++ b2/build.log 2024-05-15 20:45:40.879602357 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Tue Jun 17 15:01:00 -12 2025 -I: pbuilder-time-stamp: 1750215660 +I: Current time: Thu May 16 10:41:19 +14 2024 +I: pbuilder-time-stamp: 1715805679 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/trixie-reproducible-base.tgz] I: copying local configuration @@ -30,51 +30,83 @@ dpkg-source: info: applying 07-skip-tests-requiring-rubocop-performance.diff I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/2981196/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/D01_modify_environment starting +debug: Running on infom01-amd64. +I: Changing host+domainname to test build reproducibility +I: Adding a custom variable just for the fun of it... +I: Changing /bin/sh to bash +'/bin/sh' -> '/bin/bash' +lrwxrwxrwx 1 root root 9 May 15 20:41 /bin/sh -> /bin/bash +I: Setting pbuilder2's login shell to /bin/bash +I: Setting pbuilder2's GECOS to second user,second room,second work-phone,second home-phone,second other +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/D02_print_environment starting I: set - BUILDDIR='/build/reproducible-path' - BUILDUSERGECOS='first user,first room,first work-phone,first home-phone,first other' - BUILDUSERNAME='pbuilder1' - BUILD_ARCH='amd64' - DEBIAN_FRONTEND='noninteractive' + BASH=/bin/sh + BASHOPTS=checkwinsize:cmdhist:complete_fullquote:extquote:force_fignore:globasciiranges:globskipdots:hostcomplete:interactive_comments:patsub_replacement:progcomp:promptvars:sourcepath + BASH_ALIASES=() + BASH_ARGC=() + BASH_ARGV=() + BASH_CMDS=() + BASH_LINENO=([0]="12" [1]="0") + BASH_LOADABLES_PATH=/usr/local/lib/bash:/usr/lib/bash:/opt/local/lib/bash:/usr/pkg/lib/bash:/opt/pkg/lib/bash:. + BASH_SOURCE=([0]="/tmp/hooks/D02_print_environment" [1]="/tmp/hooks/D02_print_environment") + BASH_VERSINFO=([0]="5" [1]="2" [2]="21" [3]="1" [4]="release" [5]="x86_64-pc-linux-gnu") + BASH_VERSION='5.2.21(1)-release' + BUILDDIR=/build/reproducible-path + BUILDUSERGECOS='second user,second room,second work-phone,second home-phone,second other' + BUILDUSERNAME=pbuilder2 + BUILD_ARCH=amd64 + DEBIAN_FRONTEND=noninteractive DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=12 ' - DISTRIBUTION='trixie' - HOME='/root' - HOST_ARCH='amd64' + DIRSTACK=() + DISTRIBUTION=trixie + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=x86_64 + HOST_ARCH=amd64 IFS=' ' - INVOCATION_ID='b631a2ee7ae3418db91b7f893d32f7d0' - LANG='C' - LANGUAGE='en_US:en' - LC_ALL='C' - MAIL='/var/mail/root' - OPTIND='1' - PATH='/usr/sbin:/usr/bin:/sbin:/bin:/usr/games' - PBCURRENTCOMMANDLINEOPERATION='build' - PBUILDER_OPERATION='build' - PBUILDER_PKGDATADIR='/usr/share/pbuilder' - PBUILDER_PKGLIBDIR='/usr/lib/pbuilder' - PBUILDER_SYSCONFDIR='/etc' - PPID='2981196' - PS1='# ' - PS2='> ' + INVOCATION_ID=95cd89ae03e04535afc842830927f48d + LANG=C + LANGUAGE=et_EE:et + LC_ALL=C + MACHTYPE=x86_64-pc-linux-gnu + MAIL=/var/mail/root + OPTERR=1 + OPTIND=1 + OSTYPE=linux-gnu + PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path + PBCURRENTCOMMANDLINEOPERATION=build + PBUILDER_OPERATION=build + PBUILDER_PKGDATADIR=/usr/share/pbuilder + PBUILDER_PKGLIBDIR=/usr/lib/pbuilder + PBUILDER_SYSCONFDIR=/etc + PIPESTATUS=([0]="0") + POSIXLY_CORRECT=y + PPID=1998930 PS4='+ ' - PWD='/' - SHELL='/bin/bash' - SHLVL='2' - SUDO_COMMAND='/usr/bin/timeout -k 18.1h 18h /usr/bin/ionice -c 3 /usr/bin/nice /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.z6B52jcw/pbuilderrc_0zmZ --distribution trixie --hookdir /etc/pbuilder/first-build-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/trixie-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.z6B52jcw/b1 --logfile b1/build.log rubocop_1.39.0+dfsg-1.dsc' - SUDO_GID='109' - SUDO_UID='104' - SUDO_USER='jenkins' - TERM='unknown' - TZ='/usr/share/zoneinfo/Etc/GMT+12' - USER='root' - _='/usr/bin/systemd-run' + PWD=/ + SHELL=/bin/bash + SHELLOPTS=braceexpand:errexit:hashall:interactive-comments:posix + SHLVL=3 + SUDO_COMMAND='/usr/bin/timeout -k 24.1h 24h /usr/bin/ionice -c 3 /usr/bin/nice -n 11 /usr/bin/unshare --uts -- /usr/sbin/pbuilder --build --configfile /srv/reproducible-results/rbuild-debian/r-b-build.z6B52jcw/pbuilderrc_2mJI --distribution trixie --hookdir /etc/pbuilder/rebuild-hooks --debbuildopts -b --basetgz /var/cache/pbuilder/trixie-reproducible-base.tgz --buildresult /srv/reproducible-results/rbuild-debian/r-b-build.z6B52jcw/b2 --logfile b2/build.log rubocop_1.39.0+dfsg-1.dsc' + SUDO_GID=109 + SUDO_UID=104 + SUDO_USER=jenkins + TERM=unknown + TZ=/usr/share/zoneinfo/Etc/GMT-14 + UID=0 + USER=root + _='I: set' I: uname -a - Linux infom02-amd64 6.6.13+bpo-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.6.13-1~bpo12+1 (2024-02-15) x86_64 GNU/Linux + Linux i-capture-the-hostname 6.1.0-21-cloud-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.90-1 (2024-05-03) x86_64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 Jun 16 03:14 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/2981196/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 May 14 11:25 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -300,7 +332,7 @@ Get: 154 http://deb.debian.org/debian trixie/main amd64 ruby-simplecov all 0.22.0-1 [45.1 kB] Get: 155 http://deb.debian.org/debian trixie/main amd64 ruby-unicode-display-width all 1.6.1-1 [10.3 kB] Get: 156 http://deb.debian.org/debian trixie/main amd64 ruby-webmock all 3.18.1-2 [66.2 kB] -Fetched 49.4 MB in 1s (58.6 MB/s) +Fetched 49.4 MB in 2s (32.1 MB/s) debconf: delaying package configuration, since apt-utils is not installed Selecting previously unselected package libpython3.11-minimal:amd64. (Reading database ... (Reading database ... 5% (Reading database ... 10% (Reading database ... 15% (Reading database ... 20% (Reading database ... 25% (Reading database ... 30% (Reading database ... 35% (Reading database ... 40% (Reading database ... 45% (Reading database ... 50% (Reading database ... 55% (Reading database ... 60% (Reading database ... 65% (Reading database ... 70% (Reading database ... 75% (Reading database ... 80% (Reading database ... 85% (Reading database ... 90% (Reading database ... 95% (Reading database ... 100% (Reading database ... 19699 files and directories currently installed.) @@ -816,8 +848,8 @@ Setting up tzdata (2024a-4) ... Current default time zone: 'Etc/UTC' -Local time is now: Wed Jun 18 03:01:51 UTC 2025. -Universal Time is now: Wed Jun 18 03:01:51 UTC 2025. +Local time is now: Wed May 15 20:43:03 UTC 2024. +Universal Time is now: Wed May 15 20:43:03 UTC 2024. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up ruby-method-source (1.0.0-2) ... @@ -958,7 +990,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/rubocop-1.39.0+dfsg/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games" HOME="/nonexistent/first-build" dpkg-genchanges -S > ../rubocop_1.39.0+dfsg-1_source.changes +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for trixie +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/rubocop-1.39.0+dfsg/ && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-buildpackage -us -uc -b && env PATH="/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/i/capture/the/path" HOME="/nonexistent/second-build" dpkg-genchanges -S > ../rubocop_1.39.0+dfsg-1_source.changes dpkg-buildpackage: info: source package rubocop dpkg-buildpackage: info: source version 1.39.0+dfsg-1 dpkg-buildpackage: info: source distribution unstable @@ -987,7 +1023,7 @@ dh_prep -O--buildsystem=ruby dh_auto_install --destdir=debian/rubocop/ -O--buildsystem=ruby dh_ruby --install /build/reproducible-path/rubocop-1.39.0\+dfsg/debian/rubocop -/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20250617-2986298-41d77m/gemspec +/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20240516-2032437-56k7fi/gemspec Failed to load /dev/null because it doesn't contain valid YAML hash WARNING: open-ended dependency on parser (>= 3.1.2.1) is not recommended if parser is semantically versioned, use: @@ -997,7 +1033,7 @@ Name: rubocop Version: 1.39.0 File: rubocop-1.39.0.gem -/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/rubocop/usr/share/rubygems-integration/all /tmp/d20250617-2986298-41d77m/rubocop-1.39.0.gem +/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/rubocop/usr/share/rubygems-integration/all /tmp/d20240516-2032437-56k7fi/rubocop-1.39.0.gem Failed to load /dev/null because it doesn't contain valid YAML hash /build/reproducible-path/rubocop-1.39.0+dfsg/debian/rubocop/usr/share/rubygems-integration/all/gems/rubocop-1.39.0/assets/output.html.erb /build/reproducible-path/rubocop-1.39.0+dfsg/debian/rubocop/usr/share/rubygems-integration/all/gems/rubocop-1.39.0/config/default.yml @@ -1810,68 +1846,50 @@ RUBYLIB=. GEM_PATH=/build/reproducible-path/rubocop-1.39.0+dfsg/debian/rubocop/usr/share/rubygems-integration/all:/build/reproducible-path/rubocop-1.39.0+dfsg/debian/.debhelper/generated/_source/home/.local/share/gem/ruby/3.1.0:/var/lib/gems/3.1.0:/usr/local/lib/ruby/gems/3.1.0:/usr/lib/ruby/gems/3.1.0:/usr/lib/x86_64-linux-gnu/ruby/gems/3.1.0:/usr/share/rubygems-integration/3.1.0:/usr/share/rubygems-integration/all:/usr/lib/x86_64-linux-gnu/rubygems-integration/3.1.0 ruby3.1 -S rake --rakelibdir /gem2deb-nonexistent -f debian/ruby-tests.rake /usr/bin/ruby3.1 -I/usr/share/rubygems-integration/all/gems/rspec-support-3.13.1/lib:/usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/lib /usr/share/rubygems-integration/all/gems/rspec-core-3.13.0/exe/rspec --pattern ./spec/\*\*/\*_spec.rb --exclude-pattern spec/rubocop/config_loader_spec.rb,spec/project_spec.rb,spec/rubocop/cli/options_spec.rb,spec/rubocop/cli/suggest_extensions_spec.rb,spec/rubocop/config_obsoletion_spec.rb,spec/rubocop/lockfile_spec.rb,spec/rubocop/server/rubocop_server_spec.rb,spec/rubocop/version_spec.rb --format documentation -Randomized with seed 11464 +Randomized with seed 12564 -RuboCop::Cop::VariableForce::Assignment - #operator - when it is &&= operator assignment - returns &&= - when it is += operator assignment - returns += - when it is ||= operator assignment - returns ||= - when it is normal assignment - returns = - when it is multiple assignment - returns = - .new - when an assignment node is passed - does not raise error - when an argument declaration node is passed - raises error - when any other type node is passed - raises error - #meta_assignment_node - when it is += operator assignment - returns op_asgn node - when it is &&= operator assignment - returns and_asgn node - when it is ||= operator assignment - returns or_asgn node - when it is multiple assignment - returns masgn node - #name - returns the variable name - -RuboCop::Cop::InternalAffairs::UndefinedConfig - works with deeper nested cop names - can handle an empty file - registers an offense when the cop inherits `Cop::Base` - works when the base class is `Cop` instead of `Base` - registers an offense when the cop is not within the `RuboCop::Cop` namespace - does not register an offense if using `cop_config` outside of a cop class - ignores `cop_config` in non-cop classes - registers an offense when the cop inherits `::RuboCop::Cop::Base` - ignores `cop_config` in non-cop subclasses - registers an offense when the cop inherits `RuboCop::Cop::Base` - registers an offense when the cop has no configuration at all - does not register an offense for implicit configuration keys - element lookup - registers an offense for missing configuration keys - does not register an offense for defined configuration keys - fetch - does not register an offense for defined configuration keys - registers an offense for missing configuration keys - with a default value - does not register an offense for defined configuration keys - registers an offense for missing configuration keys +RuboCop::Cop::Style::RedundantPercentQ + accepts %q at the beginning of a double quoted string with interpolation + accepts %q at the beginning of a section of a double quoted string with interpolation + accepts a heredoc string that contains %q + accepts %Q at the beginning of a section of a double quoted string with interpolation + accepts %Q at the beginning of a double quoted string with interpolation + accepts %q containing string interpolation + with %Q strings + accepts regular expressions starting with %Q + registers an offense for dynamic string without quotes + accepts a string with single quotes and double quotes + accepts a dynamic %Q string with double quotes + accepts a string with double quotes and an escaped normal character + registers an offense for static string with only double quotes + accepts a string with double quotes and an escaped special character + registers an offense for static string without quotes + autocorrects for strings that are concatenated with backslash + with %q strings + registers an offense for only double quotes + accepts regular expressions starting with %q + accepts a string with single quotes and double quotes + autocorrects for strings that are concatenated with backslash + registers an offense for only single quotes + accepts a string with escaped non-backslash characters + registers an offense for no quotes + accepts a string with escaped backslash and non-backslash characters + registers an offense for a string containing escaped backslashes RuboCop::Cop::Naming::PredicateName without restricted prefixes - registers an offense when method name starts with "is" registers an offense when method name starts with "has" + accepts method name when corrected name is invalid identifier accepts method name that starts with unknown prefix + registers an offense when method name starts with "is" + without method definition macros + accepts method name when corrected name is invalid identifier + registers an offense when using `define_method` + does not register any offenses when using an internal affair macro + with method definition macros accepts method name when corrected name is invalid identifier + registers an offense when using `define_method` + registers an offense when using an internal affair macro with restricted prefixes registers an offense when method name starts with "is" accepts method name when corrected name is invalid identifier @@ -1880,4767 +1898,3644 @@ registers an offense when method name starts with "has" with permitted predicate names accepts method name which is in permitted list - without method definition macros - registers an offense when using `define_method` - does not register any offenses when using an internal affair macro - accepts method name when corrected name is invalid identifier - with method definition macros - accepts method name when corrected name is invalid identifier - registers an offense when using an internal affair macro - registers an offense when using `define_method` - -RuboCop::Cop::Lint::EmptyBlock - does not register an offense on an empty ::Proc.new - does not register an offense on an empty proc - does not register an offense for empty block with inline comments - does not register an offense on an empty Proc.new - does not register an offense on an empty lambda - does not register an offense for empty block with inner comments - registers an offense for empty block within method call - does not register an offense when block is not empty - registers an offense for an empty block given to a non-Kernel `proc` method - does not register an offense on an empty stabby lambda - when AllowComments is false - registers an offense for empty block with inline comments - registers an offense for empty block with inner comments - when AllowEmptyLambdas is false - registers an offense for an empty stabby lambda - registers an offense on an empty Proc.new - registers an offense for an empty lambda - registers an offense on an empty proc - registers an offense on an empty ::Proc.new -RuboCop::Cop::Style::DoubleCopDisableDirective - registers an offense for duplicate disable directives - registers an offense for duplicate todo directives - does not register an offense for cops with single cop directive +RuboCop::StringInterpreter + .interpret + handles hex + handles unicode + handles octal + handles extended unicode + behaves like simple escape + handles \\s + behaves like simple escape + handles \\r + behaves like simple escape + handles \\t + behaves like simple escape + handles \\v + behaves like simple escape + handles \\e + behaves like simple escape + handles \\f + behaves like simple escape + handles \\a + behaves like simple escape + handles \\n + behaves like simple escape + handles \\b -RuboCop::Cop::InternalAffairs::LocationLineEqualityComparison - registers and corrects an offense when comparing `#loc.source_range` with LHS and RHS - registers an offense and corrects when using `loc.first_line` - does not register an offense when using `same_line?` - registers and corrects an offense when comparing `#loc.line` with LHS and RHS - registers an offense and corrects when using `source_range.first_line` - registers an offense and corrects when using `first_line` +RuboCop::Cop::Lint::AmbiguousBlockAssociation + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + when AllowedPatterns is enabled + does not register an offense for an allowed method + registers an offense for other methods + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + when AllowedMethods is enabled + does not register an offense for an allowed method + registers an offense for other methods + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + without parentheses + as a hash key + registers an offense + with assignment + registers an offense + with receiver + registers an offense + when using safe navigation operator + registers an offense + rspec expect {}.to change {} + registers an offense + without receiver + registers an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense + behaves like accepts + does not register an offense -RuboCop::Cop::Lint::RedundantStringCoercion - registers an offense and corrects `to_s` in an interpolation with several expressions - does not explode on empty interpolation - registers an offense and corrects an implicit receiver - accepts #to_s with arguments in an interpolation - accepts interpolation without #to_s - registers an offense and corrects `to_s` in interpolation +RuboCop::Cop::Lint::DuplicateMethods + does not register an offense for same method name defined in different methods + does not register an offense for same method name defined in different methods + registers an offense for a duplicate instance method in separate dynamic class blocks + registers an offense for duplicate class methods with named receiver in module + registers an offense for duplicate class methods in dynamic class + registers an offense for duplicate alias_method in module + registers 2 offenses for pair of duplicate methods in dynamic class + registers an offense for duplicate private methods in dynamic class + understands nested modules + accepts for attr_reader and setter in dynamic module + recognizes difference between instance and class methods in dynamic module + understands nested modules + understands class << self + does not register an offense for same method name defined in different self methods + registers an offense for duplicate protected methods in dynamic module + registers an offense when class << exp is used + only registers an offense for the second instance of a duplicate instance method in separate files + registers an offense for duplicate alias_method in dynamic module + registers an offense for a duplicate class method in separate class blocks + only registers an offense for the second instance of a duplicate instance method in separate files + registers an offense for duplicate class methods with named receiver in class + registers an offense for duplicate attr_writer in class + registers an offense for duplicate protected methods in class + registers an offense for a duplicate class method in separate dynamic module blocks + doesn't register an offense for non-duplicate alias in dynamic class + does not register an offense for same method name defined in different methods + doesn't register an offense for non-duplicate alias in class_eval block + accepts for attr_writer and getter in class + registers an offense when class << exp is used + doesn't register offense for non-duplicate class methods in class + understands nested modules + registers an offense when class << exp is used + accepts for non-duplicate alias_method in module + accepts for non-duplicate alias_method in dynamic module + accepts for attr_reader and setter in class + does not register for the same method in different scopes within `class << self` + registers an offense for duplicate alias in module + accepts for attr_writer and getter in dynamic module + doesn't register an offense for non-duplicate method in dynamic class + understands class << A + ignores Class.new blocks which are assigned to local variables + registers offenses for duplicate assignable attr in class + understands class << self + registers an offense for duplicate alias in class + registers an offense for duplicate attr_reader in class_eval block + registers an offense for duplicate alias_method in class_eval block + registers an offense for duplicate private methods in module + registers an offense for a duplicate class method in separate module blocks + doesn't register an offense for different private methods in dynamic class + registers an offense for duplicate method in dynamic module + doesn't register an offense for different private methods in class_eval block + understands class << self + registers an offense for duplicate alias in class_eval block + registers an offense for duplicate nested method in self method of class_eval block + registers an offense for duplicate nested method in class + registers an offense for duplicate attr_writer in module + doesn't register an offense for alias for gvar in module + doesn't register an offense for non-duplicate alias in dynamic module + registers an offense for duplicate protected methods in dynamic class + does not register an offense for same method name defined in different self methods + registers 2 offenses for pair of duplicate methods in class + accepts for attr_reader and setter in dynamic class + registers an offense for duplicate private self methods in dynamic module + does not register an offense for same method name defined in different self methods + registers an offense for duplicate alias in dynamic class + registers offenses for duplicate assignable attr in class_eval block + doesn't register an offense for non-duplicate method in module + registers an offense for duplicate nested method in self method of module + doesn't register an offense for non-duplicate method in dynamic module + registers an offense for duplicate protected methods in class_eval block + registers an offense for duplicate attr in class + doesn't register offense for non-duplicate class methods in class_eval block + accepts for non-duplicate alias_method in class + accepts for attr_reader and setter in class_eval block + properly registers and offense when deeply nested + doesn't register an offense for different private methods in dynamic module + registers an offense for duplicate nested method in dynamic module + doesn't register an offense for non-duplicate method in class + registers an offense for duplicate attr_writer in dynamic module + registers offenses for duplicate attr_accessor in module + registers an offense for duplicate attr in module + registers an offense for duplicate nested method in module + accepts for attr_writer and getter in class_eval block + accepts for attr_reader and setter in module + only registers an offense for the second instance of a duplicate instance method in separate files + only registers an offense for the second instance of a duplicate instance method in separate files + registers an offense for duplicate attr_reader in class + registers an offense when class << exp is used + does not register an offense for same method name defined in different self methods + registers an offense for duplicate attr in dynamic class + registers an offense for duplicate nested method in class_eval block + registers an offense for duplicate alias_method in class + registers an offense for duplicate private self methods in dynamic class + registers an offense for a duplicate instance method in separate module blocks + registers an offense for duplicate attr in class_eval block + doesn't register offense for non-duplicate class methods in module + registers an offense for duplicate class methods in dynamic module + registers offenses for duplicate assignable attr in module + doesn't register offense for non-duplicate class methods in dynamic module + registers an offense for duplicate attr_reader in module + registers an offense for duplicate private methods in class + registers an offense for duplicate method in module + registers offenses for duplicate assignable attr in dynamic module + registers an offense for duplicate class methods with `self` and named receiver in class + registers an offense for duplicate class methods in class + recognizes difference between instance and class methods in class + doesn't register an offense for alias for gvar in class_eval block + registers an offense for duplicate attr_writer in class_eval block + registers an offense for duplicate attr in dynamic module + ignores method definitions in RSpec `describe` blocks + doesn't register an offense for alias for gvar in class + registers an offense for duplicate protected methods in module + does not register an offense for same method name defined in different methods + registers 2 offenses for pair of duplicate methods in class_eval block + registers offenses for duplicate assignable attr in dynamic class + registers an offense for a duplicate instance method in separate dynamic module blocks + registers an offense for duplicate method in class_eval block + registers 2 offenses for pair of duplicate methods in dynamic module + doesn't register an offense for non-duplicate method in class_eval block + understands class << self + doesn't register offense for non-duplicate class methods in dynamic class + accepts for non-duplicate alias_method in class_eval block + registers an offense for duplicate private methods in class_eval block + registers an offense for duplicate attr_writer in dynamic class + doesn't register an offense for non-duplicate alias in module + registers an offense for duplicate private self methods in class_eval block + registers an offense for duplicate private self methods in module + registers an offense for duplicate class methods in class_eval block + doesn't register an offense for alias for gvar in dynamic module + understands nested modules + registers an offense for duplicate method in class + registers an offense for duplicate nested method in dynamic class + recognizes difference between instance and class methods in class_eval block + registers an offense for duplicate class methods with `<<` and named receiver in module + registers offenses for duplicate attr_accessor in class + handles class_eval with implicit receiver + registers an offense for duplicate methods at top level + registers an offense for duplicate nested method in self method of dynamic module + registers an offense when class << exp is used + registers 2 offenses for pair of duplicate methods in module + registers offenses for duplicate attr_accessor in dynamic class + registers offenses for duplicate attr_accessor in dynamic module + registers an offense for duplicate alias in dynamic module + only registers an offense for the second instance of a duplicate instance method in separate files + registers an offense for duplicate method in dynamic class + understands class << self + doesn't register an offense for non-duplicate alias in class + recognizes difference between instance and class methods in module + doesn't register an offense for different private methods in class + registers an offense for duplicate nested method in self method of class + registers an offense for duplicate alias_method in dynamic class + registers an offense for a duplicate class method in separate dynamic class blocks + accepts for attr_writer and getter in dynamic class + doesn't register an offense for alias for gvar in dynamic class + accepts for attr_writer and getter in module + registers an offense for duplicate class methods with `<<` and named receiver in class + registers an offense for duplicate class methods in module + registers an offense for duplicate private methods in dynamic module + registers an offense for duplicate class methods with `self` and named receiver in module + registers an offense for a duplicate instance method in separate class blocks + does not register an offense for same method name defined in different self methods + understands nested modules + registers offenses for duplicate attr_accessor in class_eval block + does not register an offense for same method name defined in different methods + doesn't register an offense for different private methods in module + registers an offense for a duplicate class method in separate class_eval block blocks + registers an offense for duplicate nested method in self method of dynamic class + recognizes difference between instance and class methods in dynamic class + registers an offense for a duplicate instance method in separate class_eval block blocks + registers an offense for duplicate attr_reader in dynamic class + registers an offense for duplicate private self methods in class + accepts for non-duplicate alias_method in dynamic class + registers an offense for duplicate attr_reader in dynamic module + when path is not in the project root + adds a message with absolute path + when path is in the project root + adds a message with relative path -RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration - registers an offense when using trailing comma - does not register an offense when not using trailing comma +RuboCop::Cop::Style::RedundantInitialize + registers and corrects an offense for an `initialize` method that only calls `super` + registers an offense for an `initialize` method with a default argument that does nothing + does not register an offense for an `initialize` method that calls another method + does not register an offense for an `initialize` method with a default argument that calls `super` + does not register an offense for an `initialize` method with only a comment + registers and corrects an offense for an `initialize` method with arguments that only calls `super` with explicit args + does not register an offense for a method not named `initialize` that only calls super + does not register an offense for an `initialize` method that calls `super` with no arguments + does not register an offense for an empty `initialize` method with a argument forwarding` + does not register an offense for an `initialize` method with a default keyword argument that calls `super` + does not register an offense for an empty `initialize` method with a kwsplat` + registers and corrects an offense for an `initialize` method with no arguments that calls `super` with no arguments + registers and corrects an offense for an `initialize` method with arguments that only calls `super` + does not register an offense for an empty `initialize` method with a splat` and super + does not register an offense for an `initialize` method that calls `super` with a different argument list + does not register an offense for an empty `initialize` method with a splat` + does not register an offense for an empty method not named `initialize` + registers an offense for an `initialize` method with a default keyword argument that does nothing + does not register an offense for an `initialize` method that calls another method before `super` + does not register an offense for an `initialize` method that calls another method after `super` + registers and corrects an offense for an empty `initialize` method + when `AllowComments: false` + registers and corrects an offense for an `initialize` method with only a comment -RuboCop::Cop::Layout::MultilineAssignmentLayout - same_line style - registers an offense for masgn with multi-line lhs - allows multi-line assignments on the same line - registers an offense when the rhs is a different line - ignores arrays - registers an offense when the rhs is a different line in []= - registers an offense when the rhs is a different line in setters - configured supported types - allows supported types to be configured - when supported types is block - allows multi-line block defines on separate lines - allows when multi-line assignments using block definition is on the same line - registers an offense when multi-line assignments using block definition on separate lines - allows multi-line assignments when using shovel operator - new_line style - registers an offense for masgn with multi-line lhs - registers an offense when the rhs is on the same line - allows multi-line assignments on separate lines - registers an offense when the rhs is on the same line in []= - ignores arrays - registers an offense when the rhs is on the same line in setters - configured supported types - allows supported types to be configured - when supported types is block - allows multi-line block defines on separate lines - allows multi-line assignments when using block definition on separate lines - registers an offense when multi-line assignments using block definition is on the same line - allows multi-line assignments when using shovel operator +RuboCop::Cop::InternalAffairs::InheritDeprecatedCopClass + registers an offense when using `Cop` + does not register an offense when not inherited super class + does not register an offense when using `Base` + registers an offense when using `RuboCop::Cop::Cop` -RuboCop::Cop::Lint::MissingCopEnableDirective - when the maximum range size is infinite - does not register an offense when the disable department is re-enabled - registers an offense when a cop is disabled and never re-enabled - registers an offense when a department is disabled and never re-enabled - does not register an offense when the disable cop is re-enabled - when the cop is disabled in the config - reports no offense when re-disabling it until EOF - when the maximum range size is finite - registers an offense when a department is disabled for too many lines - does not register an offense when the disable cop is re-enabled within the limit - does not register an offense when the disable department is re-enabled within the limit - registers an offense when a cop is disabled and never re-enabled - registers an offense when a department is disabled and never re-enabled - registers an offense when a cop is disabled for too many lines +RuboCop::Cop::Layout::MultilineArrayLineBreaks + when on same line, separate line from brackets + does not add any offenses + when two elements on same line + registers an offense and corrects + when on same line + does not add any offenses + when nested arrays + registers an offense and corrects -RuboCop::Cop::Lint::UnmodifiedReduceAccumulator - behaves like reduce/inject - does not affect inject called with no block args - does not affect inject called without a block - given a inject block - does not look inside inner blocks - registers an offense with the element in interpolation - registers an offense for every violating return value - does not register an offense when op-assigning the accumulator - does not register an offense when and-assigning the accumulator - does not register an offense when returning the accumulator in a boolean statement - registers an offense when returning an index of the accumulator - does not register an offense if the return value cannot be determined - registers an offense when returning an index setter on the accumulator - registers an offense when returning the element - registers an offense when returning accumulator[element]= - does not register an offense when returning the accumulator in an expression - allows break with no value - registers an offense with the element in heredoc - does not register an offense when mutating the element with the accumulator - registers an offense for values returned with `next` - registers an offense for values returned with `break` - does not register an offense when shovelling the accumulator - does not register an offense with the accumulator in heredoc - does not register an offense when returning accumulator[element] - does not register an offense when comparing - allows the element to be the return value if the accumulator is returned in any branch - does not register an offense with the accumulator in interpolation - registers an offense when returning an expression with the element - does not register an offense when returning a literal - does not register an offense when assigning the accumulator - does not register an offense when returning a method called on the accumulator - registers an offense when mutating the accumulator with the element but not returning it - does not register an offense when returning a method called with the accumulator - registers an offense when called with no argument - does not register an offense when returning the accumulator - does not register an offense when or-assigning the accumulator - does not register an offense when mutating the element with the another value - does not register an offense when calling a method on the accumulator with the element - argument count - registers an offense when there are more than two arguments but the element is returned - ignores when there is a splat argument - ignores when there are not enough block arguments - numblocks - registers an offense when returning the element - does not register an offense when when returning the accumulator - behaves like reduce/inject - does not affect reduce called with no block args - does not affect reduce called without a block - given a reduce block - does not register an offense when shovelling the accumulator - does not register an offense when and-assigning the accumulator - does not register an offense when or-assigning the accumulator - does not register an offense when returning the accumulator in an expression - registers an offense for every violating return value - registers an offense when returning an index of the accumulator - does not register an offense when returning the accumulator in a boolean statement - does not register an offense when returning a method called on the accumulator - registers an offense when returning an expression with the element - does not register an offense when mutating the element with the another value - registers an offense for values returned with `break` - does not register an offense when mutating the element with the accumulator - does not register an offense if the return value cannot be determined - does not register an offense when returning the accumulator - does not register an offense when returning accumulator[element] - registers an offense when returning the element - does not register an offense with the accumulator in interpolation - does not register an offense when returning a method called with the accumulator - does not register an offense when comparing - allows the element to be the return value if the accumulator is returned in any branch - registers an offense with the element in heredoc - does not register an offense when op-assigning the accumulator - allows break with no value - registers an offense when returning an index setter on the accumulator - registers an offense when returning accumulator[element]= - does not look inside inner blocks - registers an offense for values returned with `next` - registers an offense with the element in interpolation - registers an offense when called with no argument - registers an offense when mutating the accumulator with the element but not returning it - does not register an offense when returning a literal - does not register an offense when calling a method on the accumulator with the element - does not register an offense when assigning the accumulator - does not register an offense with the accumulator in heredoc - numblocks - does not register an offense when when returning the accumulator - registers an offense when returning the element - argument count - ignores when there is a splat argument - ignores when there are not enough block arguments - registers an offense when there are more than two arguments but the element is returned +RuboCop::Cop::Lint::PercentSymbolArray + detecting colons or commas in a %i/%I string + accepts likely false positive $, + registers an offense and corrects when there are no colons but one comma + registers an offense and corrects when symbols contain colons and are comma separated + accepts tokens without colons or commas + registers an offense and corrects when one symbol has a colon but there are no commas + registers an offense and corrects when one symbol has a colon but there are no commas + registers an offense and corrects when there are no colons but one comma + registers an offense and corrects when symbols contain colons and are comma separated + accepts tokens without colons or commas + accepts likely false positive $, + with binary encoded source + registers an offense and corrects when tokens contain quotes + accepts if tokens contain no quotes -RuboCop::Cop::Lint::BigDecimalNew - registers an offense and corrects using `BigDecimal.new()` - registers an offense and corrects using `::BigDecimal.new()` - does not register an offense when using `BigDecimal()` +RuboCop::Cop::InternalAffairs::MethodNameEqual + registers an offense when using `#method == :do_something` + does not register an offense when using `#method?` + registers an offense when using `#method == other_node.do_something` RuboCop::Cop::Layout::EndOfLine + when EnforcedStyle is native + registers an offense for an incorrect EOL when EnforcedStyle is crlf - registers an offense for CR+LF - does not register offense for no CR at end of file accepts an empty file does not register offenses after __END__ - and the default external encoding is US_ASCII - can inspect non-UTF-8 encoded source with proper encoding comment - does not crash on UTF-8 encoded non-ascii characters + registers an offense for CR+LF + does not register offense for no CR at end of file and there are many lines ending with LF registers only one offense can inspect non-UTF-8 encoded source with proper encoding comment + and the default external encoding is US_ASCII + does not crash on UTF-8 encoded non-ascii characters + can inspect non-UTF-8 encoded source with proper encoding comment when EnforcedStyle is lf - registers an offense for CR at end of file - does not register offenses after __END__ accepts an empty file registers an offense for CR+LF + does not register offenses after __END__ + registers an offense for CR at end of file and the default external encoding is US_ASCII can inspect non-UTF-8 encoded source with proper encoding comment does not crash on UTF-8 encoded non-ascii characters and there are many lines ending with CR+LF - can inspect non-UTF-8 encoded source with proper encoding comment registers only one offense - when EnforcedStyle is native - registers an offense for an incorrect EOL + can inspect non-UTF-8 encoded source with proper encoding comment -RuboCop::Cop::InternalAffairs::RedundantDescribedClassAsSubject - registers an offense when using `subject(:cop)` and `:config` is not specified in `describe` - registers an offense when using `subject(:cop)` with no argument `described_class.new` and `:config` is specified - registers an offense when using `subject(:cop)` and `:config` is already specified in `describe` - does not register an offense when using `subject(:cop)` with multiple arguments to `described_class.new` +RuboCop::Cop::Style::OrAssignment + when using var = if var; var; else; something; end + registers an offense with class variables + registers an offense with normal variables + does not register an offense if any of the variables are different + registers an offense with instance variables + registers an offense with global variables + when using `elsif` statement + does not register an offense + when using var = var ? var : something + registers an offense with class variables + registers an offense with normal variables + registers an offense with global variables + does not register an offense if any of the variables are different + registers an offense with instance variables + when using unless var; var = something; end + registers an offense for instance variables + registers an offense for global variables + does not register an offense if any of the variables are different + registers an offense for normal variables + registers an offense for class variables + when `then` branch body is empty + registers an offense + when using var = something unless var + registers an offense for class variables + does not register an offense if any of the variables are different + registers an offense for global variables + registers an offense for normal variables + registers an offense for instance variables -RuboCop::Cop::Lint::InterpolationCheck - registers an offense for interpolation in single quoted split string - registers an offense for interpolation in double + single quoted split string - does not register an offense for interpolation in a regexp - does not register an offense for escaped crab claws in dstr - does not register an offense for an escaped interpolation - does not register an offense for properly interpolation strings - does not register an offense for interpolation in nested strings - does not crash for \xff - does not register offense for strings in %w() - registers an offense and corrects for interpolation in single quoted string - registers an offense and corrects when including interpolation and double quoted string in single quoted string +RuboCop::Cop::Style::PercentQLiterals + when EnforcedStyle is upper_case_q + without interpolation + registers offense for %q + accepts single quotes + accepts %Q + accepts double quotes + with special characters + accepts %Q + accepts %q + with interpolation + accepts %Q + accepts double quotes + accepts single quotes + accepts %q + when EnforcedStyle is lower_case_q + with interpolation + accepts %Q + accepts %q + accepts double quotes + accepts single quotes + without interpolation + accepts single quotes + registers offense for %Q + accepts %q + accepts double quotes + with special characters + accepts %Q + accepts %q -RuboCop::Cop::InternalAffairs::CreateEmptyFile - does not register an offense when using `create_file(path)` - does not register an offense when using `create_file(path, ['foo', 'bar'])` - does not register an offense when using `receiver.create_file(path, '')` - registers an offense when using `create_file(path, '') - registers an offense when using `create_file(path, "") - does not register an offense when using `create_file(path, 'hello')` +RuboCop::Cop::Style::MinMax + with an array literal containing calls to `#min` and `#max` + when the expression is used in a parallel assignment + does not register an offense if there are additional elements + registers an offense if the receivers match + does not register an offense if the receiver is implicit + does not register an offense if the receivers do not match + when the expression stands alone + does not register an offense if the receivers do not match + registers an offense if the receivers match + does not register an offense if there are additional elements + does not register an offense if the receiver is implicit + when the expression is used as a return value + does not register an offense if the receivers do not match + registers an offense if the receivers match + does not register an offense if there are additional elements + does not register an offense if the receiver is implicit -RuboCop::Cop::Style::HashTransformValues - when using Ruby 2.4 or newer - does not flag `each_with_object` when its receiver is `each_with_index` - does not flag `_.map{...}.to_h` when its receiver is `each_with_index` - does not flag each_with_object when receiver is array literal - does not flag `Hash[_.map{...}]` when its receiver is an array literal - does not flag value transformation in the absence of to_h - does not flag `each_with_object` when its receiver is `with_index` - does not flag `Hash[_.map{...}]` when its receiver is `each_with_index` - does not flag value transformation when receiver is array literal - does not flag `Hash[_.map{...}]` when its receiver is `zip` - does not flag _.map{...}.to_h when both key & value are transformed - does not flag `_.map{...}.to_h` when its receiver is `zip` - does not flag each_with_object when no transformation occurs - does not flag each_with_object when its argument is not modified - does not flag `each_with_object` when its argument is used in the value - correctly autocorrects _.map{...}.to_h with block - does not flag `each_with_object` when its receiver is `zip` - does not flag Hash[_.map{...}] when both key & value are transformed - does not flag _.map {...}.to_h when value block argument is unused - does not flag each_with_object when both key & value are transformed - does not flag `Hash[_.map{...}]` when its receiver is `with_index` - does not flag each_with_object when value transformation uses key - flags Hash[_.map{...}] when transform_values could be used - flags _.map {...}.to_h when transform_values could be used when line break before `to_h` - flags _.map {...}.to_h when transform_values could be used when wrapped in another block - flags _.map {...}.to_h when transform_values could be used - does not flag `_.map{...}.to_h` when its receiver is `with_index` - with safe navigation operator - flags each_with_object when transform_values could be used - with inline block - flags each_with_object when transform_values could be used - with multiline block - flags each_with_object when transform_values could be used - below Ruby 2.6 - does not flag _.to_h{...} - below Ruby 2.4 - does not flag even if transform_values could be used - when using Ruby 2.6 or newer - flags _.to_h{...} when transform_values could be used - does not flag `_.to_h{...}` when its receiver is `each_with_index` - register and corrects an offense _.to_h{...} when value is a hash literal and is enclosed in braces - register and corrects an offense _.to_h{...} when value is a hash literal and is not enclosed in braces - does not flag `_.to_h{...}` when its receiver is an array literal - does not flag _.to_h {...} when value block argument is unused - does not flag `_.to_h{...}` when its receiver is `with_index` - does not flag `_.to_h{...}` when its receiver is `zip` - does not flag `_.to_h{...}` when both key & value are transformed +RuboCop::Options + option + deprecated options + --auto-correct-all + emits a warning and sets the correct options instead + --safe-auto-correct + emits a warning and sets the correct options instead + --auto-correct + emits a warning and sets the correct options instead + incompatible cli options + rejects using -v with --show-cops + rejects using -V with --show-cops + rejects using -v with -V + mentions all incompatible options when more than two are used + --exclude-limit + fails if given last without argument + fails if given without --auto-gen-config + fails if given first without argument + fails if given alone without argument + --no-parallel + disables parallel from file + --parallel + combined with --fail-fast + ignores --parallel + combined with two incompatible arguments + ignores --parallel and lists both incompatible arguments + combined with --cache false + ignores --parallel + combined with an autocorrect argument + combined with --fix-layout + allows --parallel + combined with --autocorrect-all + allows --parallel + combined with --autocorrect + allows --parallel + combined with --auto-gen-config + ignores --parallel + --require + requires the passed path + --display-only-correctable + fails if given with --display-only-failed + fails if given with an autocorrect argument + --auto-gen-only-exclude + fails if given without --auto-gen-config + -h/--help + shows help text + exits cleanly + lists all builtin formatters + --disable-uncorrectable + accepts together with a safe autocorrect argument + accepts together with an unsafe autocorrect argument + fails if given without an autocorrect argument + --autocorrect + Specify --autocorrect and --autocorrect-all + emits a warning and sets some autocorrect options + Specify only --autocorrect + sets some autocorrect options + --fix-layout + sets some autocorrect options + --cache + fails if no argument is given + fails if unrecognized argument is given + accepts true as argument + accepts false as argument + --display-only-failed + fails if given without --format junit + works if given with --format junit + --display-only-fail-level-offenses + fails if given with an autocorrect argument + --cache-root + fails if no argument is given + fails if also `--cache false` is given + accepts a path as argument + --fail-level + accepts severity initial letters + accepts the "fake" severities A/autocorrect + accepts full severity names + --autocorrect-all + sets some autocorrect options + --regenerate-todo + when todo options are overridden before --regenerate-todo + is expected to eq {:auto_gen_config=>true, :exclude_limit=>"50", :offense_counts=>false, :regenerate_todo=>true} + when todo options are overridden after --regenerate-todo + is expected to eq {:auto_gen_config=>true, :exclude_limit=>"50", :offense_counts=>false, :regenerate_todo=>true} + when disabled options are overridden to be enabled + is expected to eq {:auto_gen_config=>true, :exclude_limit=>"100", :offense_counts=>true, :regenerate_todo=>true} + when no other options are given + is expected to eq {:auto_gen_config=>true, :exclude_limit=>"100", :offense_counts=>false, :regenerate_todo=>true} + --auto-gen-config + accepts other options + -s/--stdin + succeeds with exactly one path + fails if no paths are given + fails if more than one path is given + --raise-cop-error + raises cop errors + options precedence + .rubocop file + has lower precedence then command line options + has lower precedence then options from RUBOCOP_OPTS env variable + RUBOCOP_OPTS environment variable + has higher precedence then options from .rubocop file + has lower precedence then command line options + .rubocop directory + is ignored and command line options are used -RuboCop::Cop::Lint::ShadowingOuterLocalVariable - when a block block argument has same name as an outer scope variable - registers an offense - when a block argument has same name "_" as outer scope variable "_" - does not register an offense - when a block local variable has same name as an outer scope variablewith same branches of same nested `if` condition node - registers an offense - when a block local variable has same name as an outer scope variablewith same branches of same `if` condition node - registers an offense - when a block local variable has same name as an outer scope variablewith different branches of same `case` condition node - does not register an offense - when a block local variable has same name as an outer scope variablewith different branches of same `if` condition node - does not register an offense - when a block argument has a same name starts with "_" as an outer scope variable - does not register an offense - when a block local variable has same name as an outer scope variablewith same branches of same `case` condition node - registers an offense - with Ractor.new - does not register an offense - when an outer scope variable is referenced in a block - does not register an offense - when a method argument has same name as an outer scope variable - does not register an offense - when a block argument has different name with outer scope variables - does not register an offense - when multiple block arguments have same name "_" - does not register an offense - when a block local variable has same name as an outer scope variable - registers an offense - when a block local variable has same name as an outer scope variablewith different branches of same `unless` condition node - does not register an offense - when multiple block arguments have a same name starts with "_" - does not register an offense - when a block argument has same name as an outer scope variable - registers an offense - when an outer scope variable is reassigned in a block - does not register an offense - when the same variable name as a block variable is used in return value assignment of `if` - does not register an offense - when a block local variable has same name as an outer scope variablewith same branches of same `unless` condition node - registers an offense - when a block local variable has same name as an outer scope variablewith same branches of same `if` condition node not in the method definition +RuboCop::Cop::Style::SpecialGlobalVars + when style is use_english_names + when add require English is enabled + when English is already required at top-level + moves require English above replacement + leaves require English alone for $$ + when English has not been required at top-level + adds require English for $$ + adds require English for twice `$*` in nested code + does not add for replacement outside of English lib + adds require English for $$ in nested code + when add require English is disabled + autocorrects $/ to $INPUT_RECORD_SEPARATOR + registers an offense for $: + generates correct auto-config when Perl variable names are used + generates correct auto-config when mixed styles are used + registers an offense for $" + does not register an offense for backrefs like $1 + registers an offense for $$ + is clear about variables from the English library vs those not + autocorrects #$: to #{$LOAD_PATH} + registers an offense for $0 + autocorrects #{$!} to #{$ERROR_INFO} + when style is use_builtin_english_names + does not register an offenses for builtin names + does not register an offense for Perl names + generates correct auto-config when mixed styles are used + does not register an offense for backrefs like $1 + autocorrects non-preffered builtin names + generates correct auto-config when Perl variable names are used + when style is use_perl_names + does not register an offense for backrefs like $1 + registers an offense for $LOAD_PATH + autocorrects #{$LOAD_PATH} to #$: + registers an offense for $LOADED_FEATURES + registers an offense for $PROCESS_ID + autocorrects $INPUT_RECORD_SEPARATOR to $/ + registers an offense for $PROGRAM_NAME + registers an offense for $PID + +RuboCop::Cop::Style::HashConversion + does not try to correct multi-argument Hash with odd number of arguments + reports different offense for Hash[a || b] + wraps complex statements in parens if needed + reports different offense for Hash[a && b] + reports different offense for hash argument Hash[] + reports different offense for hash argument Hash[] as a method argument without parentheses + reports different offense for empty Hash[] + reports different offense for Hash[(a || b)] + registers and corrects an offense when using `zip` with argument in `Hash[]` + reports different offense for Hash[(a && b)] + registers and corrects an offense when using argumentless `zip` without parentheses in `Hash[]` + reports an offense for single-argument Hash[] + registers and corrects an offense when using argumentless `zip` with parentheses in `Hash[]` + registers and corrects an offense when using multi-argument `Hash[]` as a method argument + reports different offense for multi-argument Hash[] + reports different offense for hash argument Hash[] as a method argument with parentheses + AllowSplatArgument: true + does not register an offense for unpacked array + AllowSplatArgument: false + reports uncorrectable offense for unpacked array + +RuboCop::Cop::Lint::ReturnInVoidContext + with a class method called initialize containing a return + accepts + with a non initialize method containing a return + accepts + when return is in top scope + accepts + with a setter method containing a return with a value registers an offense - when a splat block argument has same name as an outer scope variable + with an initialize method containing a return with a value registers an offense + with a setter method containing a return without a value + accepts + with an initialize method containing a return without a value + accepts -RuboCop::Cop::Layout::HeredocIndentation - quoted by - accepts for an empty line - registers an offense for too deep indented with empty line - registers an offense for first line minus-level indented, with `-` - accepts for not indented but with whitespace - does not register an offense when not indented but with whitespace, with `-` - registers an offense for not indented enough with empty line - accepts for indented, with `~` - accepts for include empty lines - accepts for indented, but without `~` - registers an offense for minus level indented - accepts for indented, but with `-` - registers an offense for too deep indented with whitespace line - registers an offense for not indented enough with whitespace line - displays message to use `<<~` instead of `<<` - registers an offense for not indented - registers an offense for too deep indented - registers an offense for not indented, with `~` - registers an offense for not indented, without `~` - displays message to use `<<~` instead of `<<-` - when Layout/LineLength is configured - accepts for long heredoc - quoted by ' - registers an offense for minus level indented - does not register an offense when not indented but with whitespace, with `-` - accepts for not indented but with whitespace - accepts for indented, but without `~` - registers an offense for not indented, with `~` - displays message to use `<<~` instead of `<<` - registers an offense for too deep indented with whitespace line - accepts for indented, with `~` - accepts for indented, but with `-` - accepts for an empty line - registers an offense for too deep indented with empty line - registers an offense for not indented enough with empty line - registers an offense for first line minus-level indented, with `-` - registers an offense for not indented enough with whitespace line - accepts for include empty lines - displays message to use `<<~` instead of `<<-` - registers an offense for not indented, without `~` - registers an offense for too deep indented - registers an offense for not indented - when Layout/LineLength is configured - accepts for long heredoc - quoted by " - registers an offense for too deep indented with whitespace line - displays message to use `<<~` instead of `<<` - does not register an offense when not indented but with whitespace, with `-` - accepts for indented, but with `-` - accepts for indented, with `~` - accepts for not indented but with whitespace - registers an offense for not indented, with `~` - accepts for include empty lines - registers an offense for minus level indented - displays message to use `<<~` instead of `<<-` - accepts for an empty line - registers an offense for not indented - registers an offense for not indented, without `~` - registers an offense for not indented enough with empty line - registers an offense for too deep indented - registers an offense for not indented enough with whitespace line - accepts for indented, but without `~` - registers an offense for first line minus-level indented, with `-` - registers an offense for too deep indented with empty line - when Layout/LineLength is configured - accepts for long heredoc - quoted by ` - displays message to use `<<~` instead of `<<` - registers an offense for not indented enough with whitespace line - registers an offense for too deep indented - accepts for indented, with `~` - registers an offense for not indented, with `~` - displays message to use `<<~` instead of `<<-` - registers an offense for first line minus-level indented, with `-` - registers an offense for minus level indented - registers an offense for not indented enough with empty line - registers an offense for not indented - does not register an offense when not indented but with whitespace, with `-` - registers an offense for not indented, without `~` - accepts for indented, but with `-` - registers an offense for too deep indented with empty line - accepts for include empty lines - accepts for indented, but without `~` - accepts for an empty line - registers an offense for too deep indented with whitespace line - accepts for not indented but with whitespace - when Layout/LineLength is configured - accepts for long heredoc +RuboCop::Cop::Lint::LiteralInInterpolation + handles double quotes in single quotes when autocorrecting + accepts interpolation of erange where endpoints are not literals + accepts interpolation of irange where endpoints are not literals + handles backslash in single quotes when autocorrecting + accepts interpolation of xstr + handles nested interpolations when autocorrecting + accepts empty interpolation + handles backslash in double quotes when autocorrecting + does not register an offense when space literal at the end of heredoc line + behaves like literal interpolation in words literal + accepts interpolation of an array literal containing a symbol with space in %W[] + accepts interpolation of an array literal containing a string with space in %W[] + removes interpolation of a symbol literal without space in %W[] + accepts interpolation of a symbol literal with space in %W[] + removes interpolation of a string literal without space in %W[] + accepts interpolation of a string literal with space in %W[] + removes interpolation of an array containing a string literal without space in %W[] + removes interpolation of an array containing a symbol literal without space in %W[] + behaves like literal interpolation + removes interpolation around multiple %i[s1 s2] + registers an offense for %i[s1 s2] in interpolation and removes interpolation around it + registers an offense only for final %i[s1 s2] in interpolation + removes interpolation around %i[s1 s2] when there is more text + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like special keywords + registers an offense and autocorrects interpolation after __END__ + accepts strings like __END__ + behaves like literal interpolation + registers an offense only for final 0xaabb in interpolation + registers an offense for 0xaabb in interpolation and removes interpolation around it + removes interpolation around 0xaabb when there is more text + removes interpolation around multiple 0xaabb + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around multiple 123_456_789_123_456_789 + registers an offense only for final 123_456_789_123_456_789 in interpolation + removes interpolation around 123_456_789_123_456_789 when there is more text + registers an offense for 123_456_789_123_456_789 in interpolation and removes interpolation around it + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for 0o377 in interpolation and removes interpolation around it + removes interpolation around multiple 0o377 + registers an offense only for final 0o377 in interpolation + removes interpolation around 0o377 when there is more text + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for [] in interpolation and removes interpolation around it + removes interpolation around [] when there is more text + removes interpolation around multiple [] + registers an offense only for final [] in interpolation + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for 1...2 in interpolation and removes interpolation around it + removes interpolation around multiple 1...2 + registers an offense only for final 1...2 in interpolation + removes interpolation around 1...2 when there is more text + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around multiple :symbol + registers an offense for :symbol in interpolation and removes interpolation around it + removes interpolation around :symbol when there is more text + registers an offense only for final :symbol in interpolation + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around multiple -1 + registers an offense for -1 in interpolation and removes interpolation around it + registers an offense only for final -1 in interpolation + removes interpolation around -1 when there is more text + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around ["a", "b"] when there is more text + registers an offense for ["a", "b"] in interpolation and removes interpolation around it + removes interpolation around multiple ["a", "b"] + registers an offense only for final ["a", "b"] in interpolation + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like special keywords + accepts strings like __FILE__ + registers an offense and autocorrects interpolation after __FILE__ + behaves like literal interpolation + registers an offense for %i[s1 s2] in interpolation and removes interpolation around it + removes interpolation around multiple %i[s1 s2] + registers an offense only for final %i[s1 s2] in interpolation + removes interpolation around %i[s1 s2] when there is more text + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around false when there is more text + registers an offense only for final false in interpolation + removes interpolation around multiple false + registers an offense for false in interpolation and removes interpolation around it + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around 1..2 when there is more text + removes interpolation around multiple 1..2 + registers an offense for 1..2 in interpolation and removes interpolation around it + registers an offense only for final 1..2 in interpolation + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for %i[ s1 s2 ] in interpolation and removes interpolation around it + registers an offense only for final %i[ s1 s2 ] in interpolation + removes interpolation around multiple %i[ s1 s2 ] + removes interpolation around %i[ s1 s2 ] when there is more text + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like non-special string literal interpolation + registers an offense for 'foo' and removes the interpolation and quotes around 'foo' + behaves like special keywords + registers an offense and autocorrects interpolation after __LINE__ + accepts strings like __LINE__ + behaves like literal interpolation + removes interpolation around multiple 1_123 + removes interpolation around 1_123 when there is more text + registers an offense only for final 1_123 in interpolation + registers an offense for 1_123 in interpolation and removes interpolation around it + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around multiple %w[v1] + removes interpolation around %w[v1] when there is more text + registers an offense only for final %w[v1] in interpolation + registers an offense for %w[v1] in interpolation and removes interpolation around it + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for 1 in interpolation and removes interpolation around it + removes interpolation around multiple 1 + registers an offense only for final 1 in interpolation + removes interpolation around 1 when there is more text + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + in string-like contexts + removes interpolation in regular expressions + removes interpolation in backticks + removes interpolation in symbols + behaves like literal interpolation in words literal + removes interpolation of a symbol literal without space in %I[] + removes interpolation of a string literal without space in %I[] + removes interpolation of an array containing a symbol literal without space in %I[] + accepts interpolation of an array literal containing a symbol with space in %I[] + accepts interpolation of a symbol literal with space in %I[] + removes interpolation of an array containing a string literal without space in %I[] + accepts interpolation of a string literal with space in %I[] + accepts interpolation of an array literal containing a string with space in %I[] + behaves like literal interpolation + removes interpolation around %w[] when there is more text + removes interpolation around multiple %w[] + registers an offense for %w[] in interpolation and removes interpolation around it + registers an offense only for final %w[] in interpolation + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around multiple true + registers an offense for true in interpolation and removes interpolation around it + registers an offense only for final true in interpolation + removes interpolation around true when there is more text + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around nil when there is more text + removes interpolation around multiple nil + registers an offense for nil in interpolation and removes interpolation around it + registers an offense only for final nil in interpolation + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense for {"a" => "b"} in interpolation and removes interpolation around it + registers an offense only for final {"a" => "b"} in interpolation + removes interpolation around {"a" => "b"} when there is more text + removes interpolation around multiple {"a" => "b"} + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around %I[s1 s2] when there is more text + registers an offense only for final %I[s1 s2] in interpolation + removes interpolation around multiple %I[s1 s2] + registers an offense for %I[s1 s2] in interpolation and removes interpolation around it + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense only for final 1.2e-3 in interpolation + registers an offense for 1.2e-3 in interpolation and removes interpolation around it + removes interpolation around multiple 1.2e-3 + removes interpolation around 1.2e-3 when there is more text + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like special keywords + registers an offense and autocorrects interpolation after __ENCODING__ + accepts strings like __ENCODING__ + behaves like non-special string literal interpolation + registers an offense for "foo" and removes the interpolation and quotes around "foo" + behaves like literal interpolation + registers an offense for 2.0 in interpolation and removes interpolation around it + removes interpolation around 2.0 when there is more text + registers an offense only for final 2.0 in interpolation + removes interpolation around multiple 2.0 + when there is non-literal and literal interpolation + when literal interpolation is before non-literal + only removes interpolation around literal + when literal interpolation is after non-literal + only removes interpolation around literal + behaves like literal interpolation + registers an offense only for final %w[v1 v2] in interpolation + registers an offense for %w[v1 v2] in interpolation and removes interpolation around it + removes interpolation around %w[v1 v2] when there is more text + removes interpolation around multiple %w[v1 v2] + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal + behaves like literal interpolation + removes interpolation around :"symbol" when there is more text + registers an offense only for final :"symbol" in interpolation + registers an offense for :"symbol" in interpolation and removes interpolation around it + removes interpolation around multiple :"symbol" + when there is non-literal and literal interpolation + when literal interpolation is after non-literal + only removes interpolation around literal + when literal interpolation is before non-literal + only removes interpolation around literal -RuboCop::CLI --autocorrect - does not say [Corrected] if correction is not possible - corrects Lint/ParenthesesAsGroupedExpression and offenses and accepts Style/RedundantParentheses - can correct IndentHash offenses with separator style - corrects LineEndConcatenation offenses leaving the RedundantInterpolation offense unchanged - breaks line at the beginning of trailing class/module body without removing a semicolon in the bodywhen using `Style/TrailingBodyOnClass` and `Style/TrailingBodyOnModule` - honors Exclude settings in individual cops - can be disabled for any cop in configuration - can correct a problems and the problem it creates - consistently quotes symbol keys in a hash using `Lint/SymbolConversion` with `EnforcedStyle: consistent` and `Style/QuotedSymbols` - corrects `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` with `Style/CommentedKeyword` and `Layout/BlockEndNewline` - does not crash Lint/SafeNavigationWithEmpty and offenses and accepts Style/SafeNavigation when checking `foo&.empty?` in a conditional - corrects `Style/TernaryParentheses` offenses and accepts `Lint/ParenthesesAsGroupedExpression` - corrects `Style/InverseMethods` offenses when specifying `IncludeSemanticChanges: false` of `Style/NonNilCheck` and `EnforcedStyle: comparison` of `Style/NilComparison` - handles different SpaceInsideBlockBraces and SpaceInsideHashLiteralBraces - corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Layout/SpaceBeforeFirstArg` - corrects SymbolProc and SpaceBeforeBlockBraces offenses - corrects IndentationWidth and IndentationConsistency offenseswithout correcting `Style/TrailingBodyOnClass` - corrects `Style/SoleNestedConditional` with `Style/InverseMethods` and `Style/IfUnlessModifier` - can correct HashSyntax and SpaceAroundOperators offenses - does not correct SpaceAroundOperators in a hash that would be changed back - can correct single line methods - corrects TrailingCommaIn(Array|Hash)Literal and Multiline(Array|Hash)BraceLayout offenses - can change block comments and indent them - can correct MethodDefParentheses and other offense - can correct MethodCallWithoutArgsParentheses and EmptyLiteral offenses - indents the elements of a hash in hash based on the parent hash key when the parent hash is a method argument and has following other sibling pairs - corrects only IndentationWidth without crashing - does not hang SpaceAfterPunctuation and SpaceInsideParens - can correct TrailingEmptyLines and TrailingWhitespace offenses - corrects RedundantCopDisableDirective offenses - corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `Layout/HashAlignment` - corrects Style/InverseMethods and Style/Not offenses - does not crash when using Lint/SafeNavigationWithEmpty and Layout/EmptyLinesAroundBlockBody - can correct HashSyntax when --only is used - properly autocorrects when `Style/TernaryParentheses` requires parentheses that `Style/RedundantParentheses` would otherwise remove - corrects Layout/RedundantLineBreak and Layout/SingleLineBlockChain offenses - corrects `Layout/SpaceAroundOperators` and `Layout/ExtraSpacing` offenses when using `ForceEqualSignAlignment: true` - does not correct Style/IfUnlessModifier offense disabled by a comment directive and does not fire Lint/RedundantCopDisableDirective offense even though that directive would make the modifier form too long - corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Style/NestedParenthesizedCalls` - corrects InitialIndentation offenses - corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedColonStyle: separator` of `Layout/HashAlignment` - corrects IndentationWidth and IndentationConsistency offenseswhen using `EnforcedStyle: outdent` and `EnforcedStyle: indented_internal_methods` - can correct two problems in the same place - corrects Style/BlockDelimiters offenses when specifyingLayout/SpaceInsideBlockBraces together - does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent_relative_to_receiver` of `Layout/FirstArgumentIndentation` - corrects indentation for a begin/rescue/else/ensure/end block properly - corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `EnforcedStyle: conditionals` of `Style/AndOr` - does not correct ExtraSpacing in a hash that would be changed back - corrects `Style/RedundantBegin` with `Style/MultilineMemoization` - corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent` of `Layout/FirstArgumentIndentation` - registers an offense and corrects when using `Layout/ArgumentAlignment`, `Layout/FirstArgumentIndentation`, and `Layout/FirstMethodArgumentLineBreak` and specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent` of `Layout/FirstArgumentIndentation` - plays nicely with default cops in complex ExtraSpacing scenarios - can correct WordArray and SpaceAfterComma offenses - can correct indentation and another thing - corrects HeredocArgumentClosingParenthesis offenses and ignores TrailingCommaInArguments offense - can correct two problems with blocks - corrects RedundantBegin offenses and fixes indentation etc - can correct SpaceAfterComma and HashSyntax offenses - corrects IndentationWidth and IndentationConsistency offenses - corrects `Naming/RescuedExceptionsVariableName` and `, `Style/RescueStandardError`and `Lint/OverwriteByRescue` offenses - corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `Layout/HashAlignment` and `Layout/FirstHashElementIndentation` - corrects Style/BlockDelimiters offenses when specifyingLayout/SpaceBeforeBlockBraces with `EnforcedStyle: no_space` together - corrects `Lint/Lambda` and `Lint/UnusedBlockArgument` offenses - says [Correctable] if correction is unsafe - corrects `EnforcedStyle: hash_rockets` of `Style/HashSyntax` with `Layout/HashAlignment` - can correct empty line inside special form of nested modules - corrects Tab and IndentationConsistency offenses - properly corrects when `Style/SoleNestedConditional` and one of `Style/NegatedIf` or `Style/NegatedUnless` detect offenses - corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Style/RescueModifier` - avoids adding extra spaces when both `Style/Semicolon` and `Style/SingleLineMethods`both apply - corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedColonStyle: separator` of `Layout/HashAlignment` (`EnforcedColonStyle` is array) - corrects IndentationWidth, RedundantBegin, and RescueEnsureAlignment offenses - corrects Style/Next and Style/SafeNavigation offenses - corrects code with indentation problems - can correct two empty lines at end of class body - corrects properly when both `Style/MapToHash` and `Style/HashTransformKeys`or `Style/HashTransformValues` registers - corrects `Layout/DotPosition` and `Layout/SingleLineBlockChain` offenses - corrects `Layout/DotPosition` and `Style/RedundantSelf` offenses - does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: special_for_inner_method_call_in_parentheses` of `Layout/FirstArgumentIndentation` - corrects `Style/IfUnlessModifier` with `Style/SoleNestedConditional` - corrects `Lint/UnusedMethodArgument` with `Style/ExplicitBlockArgument` - corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedHashRocketStyle: separator` of `Layout/HashAlignment` - does not hang SpaceAfterPunctuation and SpaceInsideArrayLiteralBrackets - corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Lint/AmbiguousOperator` - does not crash when using `Layout/CaseIndentation` and `Layout/ElseAlignment` - does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: special_for_inner_method_call` of `Layout/FirstArgumentIndentation` - space_inside_bracket cops - when array style is compact & reference style is space - corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets - when array style is space & reference style is no space - corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets - when array style is compact & reference style is no_space - corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets - when array style is no_space & reference style is space - corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets - trailing comma cops - when the style is `comma` - corrects TrailingCommaInLiteral and TrailingCommaInArguments without producing a double comma - when the style is `consistent_comma` - corrects TrailingCommaInLiteral and TrailingCommaInArguments without producing a double comma - when BlockDelimiters has braces_for_chaining style - corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses - when BlockDelimiters has semantic style - corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses - caching - with no offenses in the cache - doesn't correct offenses - with an offense in the cache - corrects offenses - when BlockDelimiters has line_count_based style - corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses +RuboCop::Cop::Style::TrailingMethodEndStatement + does not register on single line no op + register offense with trailing end on 2 line method + register offense with trailing end on method with block + register offense with trailing end inside class + autocorrects all trailing ends for larger example + does not register on single line method + register offense with trailing end on 3 line method + register offense with trailing end on method with comment + when Ruby 3.0 or higher + does not register an offense when using endless method definition + does not register an offense when endless method definition signature and body are on different lines -RuboCop::Cop::Style::SelfAssignment - registers an offense for non-shorthand assignment ** and x - registers an offense for non-shorthand assignment - and @@x - registers an offense for non-shorthand assignment * and @x - registers an offense for non-shorthand assignment || and @@x - registers an offense for non-shorthand assignment && and @x - registers an offense for non-shorthand assignment | and @@x - registers an offense for non-shorthand assignment / and x - registers an offense for non-shorthand assignment / and @@x - registers an offense for non-shorthand assignment - and @x - registers an offense for non-shorthand assignment | and x - registers an offense for non-shorthand assignment & and x - registers an offense for non-shorthand assignment - and x - registers an offense for non-shorthand assignment + and x - registers an offense for non-shorthand assignment + and @@x - registers an offense for non-shorthand assignment ** and @x - registers an offense for non-shorthand assignment | and @x - registers an offense for non-shorthand assignment && and x - registers an offense for non-shorthand assignment ** and @@x - registers an offense for non-shorthand assignment + and @x - registers an offense for non-shorthand assignment & and @@x - registers an offense for non-shorthand assignment || and @x - registers an offense for non-shorthand assignment & and @x - registers an offense for non-shorthand assignment * and x - registers an offense for non-shorthand assignment && and @@x - registers an offense for non-shorthand assignment / and @x - registers an offense for non-shorthand assignment || and x - registers an offense for non-shorthand assignment * and @@x +RuboCop::Cop::Style::FloatDivision + EnforcedStyle is fdiv + registers offense and corrects for both coerce + registers offense and corrects for left coerce + does not register offense on usage of fdiv + registers offense and corrects for right coerce + registers offense and corrects for left coerce with calculations + EnforcedStyle is right_coerce + does not register offense for right coerce + registers offense and corrects for left coerce with calculations + registers offense and corrects for both coerce + registers offense and corrects for left coerce + EnforcedStyle is single_coerce + registers offense and corrects for both coerce + registers offense and corrects for left coerce with calculations + does not register offense for right coerce only + does not register offense for left coerce only + EnforcedStyle is left_coerce + registers offense and corrects for right coerce + does not register offense for left coerce + registers offense and corrects for right coerce with calculations + registers offense and corrects for both coerce -RuboCop::Cop::Style::MissingElse - configured to warn only on empty if - given an unless-statement - with no else-clause - registers an offense - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - given a case statement - with an else-clause with side-effects - doesn't register an offense - with no else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - >= Ruby 2.7 - does not register an offense - given an if-statement - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause +RuboCop::Cop::Style::ClassEqualityComparison + does not register an offense when using `instance_of?` + registers an offense and corrects when comparing class using `==` for equality + registers an offense and corrects when comparing single quoted class name for equality + registers an offense and corrects when comparing class using `equal?` for equality + registers an offense and corrects when comparing `Module#name` for equality + registers an offense and corrects when comparing class using `eql?` for equality + registers an offense and corrects when comparing double quoted class name for equality + when AllowedMethods is enabled + does not register an offense when comparing class for equality + with String comparison in module + registers and corrects an offense + with instance variable comparison in module + registers and corrects an offense + when AllowedPatterns is enabled + does not register an offense when comparing class for equality + +RuboCop::Cop::Lint::NumberConversion + IgnoredClasses + when using DateTime + when using Time + when using Time/DateTime with multiple method calls + to_method in symbol form + registers offense with try + registers offense and autocorrects without parentheses + registers offense and autocorrects + does not register an offense when using `Complex` constructor + registers offense with send + registers an offense when using nested number conversion methods + does not register an offense when using `Float` constructor + does not register an offense when using `Integer` constructor + AllowedMethods + does not register an offense for an allowed method + registers an offense for other methods + AllowedPatterns + does not register an offense for an allowed method + registers an offense for other methods + does not register an offense + when using Integer() with integer + when `#to_i` called without a receiver + when using Float() + when using Complex() + when `:to_f` is one of multiple method arguments + registers an offense + when using `#to_r` + when using `#to_f` for number literals + when using `#to_r` for number literals + when `#to_i` called on a hash value + when using `#to_i` for number literals + when `#to_i` called on a variable + when `#to_i` called on a variable on a array + when using `#to_c` + when using `#to_i` + when using `#to_c` for number literals + when using `#to_f` + when `#to_i` called on a variable on a hash + +RuboCop::Cop::Style::HashExcept + does not register an offense when using `reject` and comparing with `lvar != :key` + does not register an offense when using `reject` and `include?` + does not register an offense when using `select` and comparing with `:key == lvar` + does not register an offense when using `select` and comparing with `lvar == :key` + does not register an offense when not using block` + does not register an offense when using `reject` and comparing with `:key != lvar` + does not register an offense when not using key block argument` + does not register an offense when using `Hash#except` + Ruby 2.7 or lower + does not register an offense when using `select` and comparing with `:key != lvar` + does not register an offense when using `select` and comparing with `lvar != :key` + does not register an offense when using `reject` and comparing with `lvar == :key` + does not register an offense when using `reject` and comparing with `:key == lvar` + Ruby 3.0 or higher + registers and corrects an offense when using `reject` and comparing with `:sym == lvar` + registers and corrects an offense when using `select` and comparing with `lvar != :sym` + does not register an offense when using `delete_if` and comparing with `lvar == :sym` + registers and corrects an offense when using `reject` and other than comparison by string and symbol using `eql?` + registers and corrects an offense when using `reject` and comparing with `lvar == :sym` + registers and corrects an offense when using `select` and comparing with `:sym != lvar` + registers and corrects an offense when using `reject` and comparing with `lvar == 'str'` + registers and corrects an offense when using `filter` and comparing with `lvar != :sym` + does not register an offense when comparing with hash value + does not register an offense when using `reject` and other than comparison by string and symbol using `==` + does not register an offense when using `keep_if` and comparing with `lvar != :sym` + when `AllCops/ActiveSupportExtensionsEnabled: true` + does not register an offense when using `delete_if` and comparing with `lvar == :sym` + registers and corrects an offense when using `reject` and comparing with `lvar == :sym` + does not register an offense when comparing with hash value + registers and corrects an offense when using `select` and comparing with `:sym != lvar` + registers and corrects an offense when using `filter` and comparing with `lvar != :sym` + does not register an offense when using `reject` and other than comparison by string and symbol using `==` + registers and corrects an offense when using `reject` and comparing with `lvar == 'str'` + registers and corrects an offense when using `select` and comparing with `lvar != :sym` + registers and corrects an offense when using `reject` and comparing with `:sym == lvar` + registers and corrects an offense when using `reject` and other than comparison by string and symbol using `eql?` + does not register an offense when using `keep_if` and comparing with `lvar != :sym` + using `include?` + registers and corrects an offense when using `reject` and calling `include?` method with variable + registers and corrects an offense when using `filter` and calling `!include?` method with symbol array + registers and corrects an offense when using `reject` and calling `include?` method with method call + registers and corrects an offense when using `reject` and calling `include?` method with symbol array + registers and corrects an offense when using `select` and calling `!include?` method with symbol array + registers and corrects an offense when using `reject` and calling `include?` method with dynamic symbol array + registers and corrects an offense when using `reject` and calling `include?` method with dynamic string array + using `in?` + registers and corrects an offense when using `reject` and calling `key.in?` method with variable + registers and corrects an offense when using `reject` and calling `key.in?` method with dynamic string array + registers and corrects an offense when using `select` and calling `!key.in?` method with symbol array + registers and corrects an offense when using `reject` and calling `key.in?` method with symbol array + registers and corrects an offense when using `filter` and calling `!key.in?` method with symbol array + registers and corrects an offense when using `reject` and calling `key.in?` method with method call + registers and corrects an offense when using `reject` and calling `key.in?` method with dynamic symbol array + does not register an offense when using `reject` and calling `in?` method with symbol array and second block value + using `exclude?` + registers and corrects an offense when using `filter` and calling `exclude?` method with symbol array + registers and corrects an offense when using `reject` and calling `!exclude?` method with symbol array + registers and corrects an offense when using `reject` and calling `!exclude?` method with method call + registers and corrects an offense when using `select` and calling `exclude?` method with symbol array + registers and corrects an offense when using `reject` and calling `!exclude?` method with dynamic symbol array + registers and corrects an offense when using `reject` and calling `!exclude?` method with variable + registers and corrects an offense when using `reject` and calling `!exclude?` method with dynamic string array + does not register an offense when using `reject` and calling `exclude?` method with symbol array and second block value + using `exclude?` + does not register offenses when using `reject` and calling `!exclude?` method with symbol array + using `include?` + registers and corrects an offense when using `select` and calling `!include?` method with symbol array + registers and corrects an offense when using `filter` and calling `!include?` method with symbol array + registers and corrects an offense when using `reject` and calling `include?` method with variable + registers and corrects an offense when using `reject` and calling `include?` method with dynamic string array + registers and corrects an offense when using `reject` and calling `include?` method with dynamic symbol array + registers and corrects an offense when using `reject` and calling `include?` method with method call + registers and corrects an offense when using `reject` and calling `include?` method with symbol array + does not register an offense when using `reject` and calling `include?` method with symbol array and second block value + using `in?` + does not register offenses when using `reject` and calling `key.in?` method with symbol array + +RuboCop::Cop::Layout::LineContinuationSpacing + EnforcedStyle: no_space + ignores heredocs and comments + registers an offense when one space in front of backslash + marks the offense correctly when offense is not in first line + registers no offense with zero spaces in front of backslash + ignores empty code + registers an offense when many spaces in front of backslash + ignores when too much space in front of backslash after `__END__` + EnforcedStyle: space + ignores heredocs and comments + marks the offense correctly when offense is not in first line + registers an offense when no space in front of backslash + ignores empty code + registers an offense when too much space in front of backslash + ignores when too much space in front of backslash after `__END__` + registers no offense with one space in front of backslash + +RuboCop::Cop::Security::CompoundHash + registers an offense when using bitshift and OR + registers an offense when using XOR assignment operator in the implementation of the hash method + does not register an offense when delegating to Array#hash + registers an offense when using multiplication in the implementation of the hash method + registers an offense when using XOR operator in the implementation of the hash method, even if intermediate variable is used + registers an offense when using XOR between an array hash and a class + registers an offense when using addition assignment operator in the implementation of the hash method + registers an offense when using XOR operator in the implementation of a dynamic hash method + registers an offense when using XOR involving super + registers an offense when using XOR operator in the implementation of the hash singleton method + registers an offense for complex usage + registers an offense when using multiplication assignment operator in the implementation of the hash method + registers an offense when using addition in the implementation of the hash method + registers an offense when using XOR operator in the implementation of the hash method, even without sub-calls to hash + registers an offense if .hash is called on any elements of a hashed array + registers an offense when using XOR operator in the implementation of the hash method + does not register an offense when delegating to a single object + registers an offense when using XOR operator in the implementation of a dynamic hash singleton method + registers an offense when delegating to Array#hash for a single value + registers an offense when using XOR and bitshifts + +RuboCop::Cop::Generator + .new + does not accept an unqualified cop + #write_source + generates a helpful source file with the name filled in + refuses to overwrite existing files + #inject_config + when it is the first in alphabetical order + inserts the cop + with version provided + uses the provided version + when it is the middle in alphabetical order + inserts the cop + when it is the last in alphabetical order + inserts the cop + compliance with rubocop + generates a cop file that has no offense (PENDING: Temporarily skipped with xit) + generates a spec file that has no offense (PENDING: Temporarily skipped with xit) + #write_spec + refuses to overwrite existing files + generates a helpful starting spec file with the class filled in + nested departments + generates source and spec files correctly namespaced within departments + #todo + provides a checklist for implementing the cop + #snake_case + converts "RSpecFoo/Bar" to snake_case + converts "Lint" to snake_case + converts "FooBar" to snake_case + converts "RSpec" to snake_case + converts "RSpec/Foo" to snake_case + converts "FooBar/Baz" to snake_case + +RuboCop::Cop::Lint::RedundantCopEnableDirective + registers an offense and corrects when the first cop is unnecessarily enabled + registers correct offense when combined with necessary enable + registers correct offense when combined with necessary enable, no white-space after comma + registers offense and corrects unnecessary enable + registers offense and corrects redundant enabling of same cop + registers multiple offenses and corrects the same comment + when middle cop is unnecessarily enabled + registers an offense and corrects when there is extra white space + registers an offense and corrects + when all cops are unnecessarily enabled + on the same line + registers an offense and corrects + on separate lines + registers an offense and corrects when there is extra white space + when last cop is unnecessarily enabled + registers an offense and corrects + registers an offense and corrects when there is no space between the cops and the comma + when cop is disabled in the configuration + registers an offense if enabling it twice + registers no offense when enabling the cop + all switch + registers offense and corrects unnecessary enable all + when at least one cop was disabled + does not register offense + when all department enabled + registers an offense and corrects when the first department is unnecessarily enabled + registers correct offense when combined with necessary enable + registers offense and corrects redundant enabling of department of same cop + registers offense and corrects redundant enabling of cop of same department + registers offense and corrects unnecessary enable + registers multiple offenses and corrects the same comment + registers offense and corrects redundant enabling of same department + +RuboCop::Cop::InternalAffairs::RedundantDescribedClassAsSubject + registers an offense when using `subject(:cop)` and `:config` is already specified in `describe` + registers an offense when using `subject(:cop)` and `:config` is not specified in `describe` + does not register an offense when using `subject(:cop)` with multiple arguments to `described_class.new` + registers an offense when using `subject(:cop)` with no argument `described_class.new` and `:config` is specified + +RuboCop::Cop::Layout::DotPosition + Leading dots style + accepts leading do in multi-line method call + registers an offense for correct + opposite + registers an offense for trailing dot in multi-line call + does not err on method call with no dots + registers an offense for only dot line + does not err on method call on same line + does not err on method call without a method name + when the receiver is a heredoc + registers an offense + when a method spans multiple lines + registers an offense + when there is an intervening line comment + does not register offense + with multiple offenses + registers all of them + when there is an intervening blank line + does not register offense + when using safe navigation operator + registers an offense for correct + opposite + accepts leading do in multi-line method call + when the receiver has a heredoc argument + with a dynamic heredoc registers an offense - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - EmptyElse enabled and set to warn on empty - given an if-statement - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause + as the first argument registers an offense - given an unless-statement - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with no else-clause + as the last argument registers an offense - >= Ruby 2.7 - does not register an offense - given a case statement - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause + with another method on the same line + does not register an offense + with multiple heredocs registers an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - configured to warn only on empty case - given an unless-statement - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with no else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - >= Ruby 2.7 - does not register an offense - given a case statement - with an else-clause with side-effects - doesn't register an offense - with no else-clause + Trailing dots style + does not err on method call with multi-line arguments + does not err on method call with no dots + accepts trailing dot in multi-line method call + does not err on method call without a method name + registers an offense for leading dot in multi-line call + does not get confused by several lines of chained methods + does not err on method call on same line + when the receiver is a heredoc + registers an offense + when there is a heredoc with a following method + does not register an offense for a heredoc + when the receiver has a heredoc argument + with a dynamic heredoc registers an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - given an if-statement - with no else-clause - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - EmptyElse enabled and set to warn on nil - given an unless-statement - with no else-clause + as the last argument registers an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - given a case statement - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause + with another method on the same line + does not register an offense + with multiple heredocs registers an offense - given an if-statement - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with no else-clause + as the first argument registers an offense - with a completely empty else-clause - doesn't register an offense - >= Ruby 2.7 - does not register an offense - UnlessElse enabled - given an unless-statement - with no else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - given an if-statement - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause + when using safe navigation operator + accepts trailing dot in multi-line method call + registers an offense for correct + opposite + +RuboCop::Formatter::EmacsStyleFormatter + #file_finished + displays parsable text + when the offense is automatically corrected + prints [Corrected] along with message + when the offense is marked as todo + prints [Todo] along with message + when the offense message contains a newline + strips newlines out of the error message + #finished + does not report summary + +RuboCop::Cop::Naming::MemoizedInstanceVariableName + does not register an offense when or-assignment-based memoization is used outside a method definition + with default EnforcedStyleForLeadingUnderscores => disallowed + when or-assignment-based memoization is used + memoized variable matches method name + does not register an offense when method has leading `_` + does not register an offense + does not register an offense with a leading `_` for both names + non-memoized variable does not match method name + does not register an offense + memoized variable matches method name for block + does not register an offense + code follows memoized variable assignment + does not register an offense + instance variables in initialize methods + does not register an offense + memoized variable after other code + does not register an offense + memoized variable matches predicate method name + does not register an offense + memoized variable matches bang method name + does not register an offense + memoized variable matches method name during assignment + does not register an offense + memoized variable does not match class method name registers an offense - given a case statement - with no else-clause + memoized variable does not match method name registers an offense - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - >= Ruby 2.7 - does not register an offense - UnlessElse disabled - given an unless-statement - with a completely empty else-clause - doesn't register an offense - with no else-clause + memoized variable does not match method name for block registers an offense - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - given an if-statement - with an else-clause containing only the literal nil - doesn't register an offense - with no else-clause + memoized variable after other code does not match method name registers an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - given a case statement - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with no else-clause + registers an offense for a bang method + registers an offense for a predicate method + with dynamically defined methods + when the variable name does not match the method name + registers an offense + when a method is defined inside a module callback + when the method matches + does not register an offense + when the method does not match + registers an offense + when a singleton method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when the variable name matches the method name + does not register an offense + memoized variable does not match method name during assignment registers an offense - >= Ruby 2.7 + when defined?-based memoization is used + does not register an offense when some code after assignment + registers an offense when memoized variable does not match class method name + registers an offense when memoized variable does not match method name + does not register an offense when there is no assignment + does not register an offense when some code before defined + with dynamically defined methods + when the variable name does not match the method name + registers an offense + when the variable name matches the method name + does not register an offense + when a singleton method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when a method is defined inside a module callback + when the method matches + does not register an offense + when the method does not match + registers an offense + memoized variable matches method name + does not register an offense + does not register an offense when memoized variable matches predicate method name + does not register an offense when method has leading `_` + does not register an offense when memoized variable matches bang method name + does not register an offense with a leading `_` for both names + non-memoized variable does not match method name + does not register an offense + EnforcedStyleForLeadingUnderscores: optional + when or-assignment-based memoization is used + memoized variable matches method name + does not register an offense with a leading `_` for both names + does not register an offense with a leading underscore + does not register an offense with a leading `_` for method name + does not register an offense without a leading underscore + when defined?-based memoization is used + memoized variable matches method name + does not register an offense with a leading `_` for both names + does not register an offense with a leading `_` for method name + does not register an offense with a leading underscore + does not register an offense without a leading underscore + EnforcedStyleForLeadingUnderscores: required + when defined?-based memoization is used + does not register an offense with a leading `_` for both names + registers an offense when names match but missing a leading _ + registers an offense when it has leading `_` but names do not match + with dynamically defined methods + when a method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when the variable name matches the method name + does not register an offense + when the variable name does not match the method name + registers an offense + when a singleton method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when or-assignment-based memoization is used + registers an offense when names match but missing a leading _ + does not register an offense with a leading `_` for both names + registers an offense when it has leading `_` but names do not match + with dynamically defined methods + when a singleton method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when the variable name matches the method name + does not register an offense + when a method is defined inside a module callback + when the method does not match + registers an offense + when the method matches + does not register an offense + when the variable name does not match the method name + registers an offense + +RuboCop::Formatter::HTMLFormatter + outputs the result in HTML + outputs the cached result in HTML + +RuboCop::Cop::InternalAffairs::CopDescription + The description starts with `This cop ...` + registers an offense if using an auxiliary verb + registers an offense and corrects if using just a verb + registers an offense if the description like `This cop is ...` + There is no description comment + does not register offense + The description starts with a word such as verb + does not register if the description like `Checks` + does not register if the description starts with non-verb word + +RuboCop::Cop::Style::RedundantReturn + does not blow up on empty method body + reports an offense for def ending with return + does not blow up on empty if body + autocorrects by removing redundant returns + accepts return in a non-final position + reports an offense for defs ending with return + reports an offense for def ending with return with splat argument + reports an offense for defs with only a return + reports an offense for def with only a return + when return has no arguments + behaves like common behavior + registers an offense for return() and autocorrects replacing return() with nil + behaves like common behavior + registers an offense for return and autocorrects replacing return with nil + when rescue and return blocks present + registers an offense and autocorrects when rescue has else clause + registers an offense and autocorrects when inside function or rescue block + when multi-value returns are allowed + accepts def with only a return + accepts defs ending with return + accepts def ending with return + accepts defs with only a return + when return is inside begin-end body + registers an offense and autocorrects + when return is inside an if-branch + registers an offense and autocorrects + when return is inside a when-branch + registers an offense and autocorrects + when multi-value returns are not allowed + autocorrects by making an implicit hash explicit + reports an offense for def with only a return + reports an offense for defs with only a return + autocorrects by removing return when using an explicit hash + reports an offense for defs ending with return + reports an offense when multiple return values have a parenthesized return value + reports an offense for def ending with return + when case nodes are empty + accepts empty when nodes + +RuboCop::Cop::Layout::MultilineOperationIndentation + when EnforcedStyle is indented + accepts alignment inside a grouped expression + accepts indentation of return if condition + accepts indented operands in if body + registers an offense and corrects aligned operands in if conditions + registers an offense for a 2 space indentation of while condition + accepts double indentation of while condition + registers an offense for a 2 space indentation of until condition + accepts indented operands in until body + accepts no extra indentation of third line + accepts indentation of return unless condition + accepts two spaces indentation in assignment of array element + registers an offense for a 2 space indentation of unless condition + accepts double indentation of unless condition + accepts the indentation of a broken string + accepts two spaces indentation of second line + registers an offense and corrects extra indentation of third line + accepts double indentation of until condition + accepts double indentation of if condition + accepts indented operands inside and outside a block + accepts indented operands in while body + accepts normal indentation of method parameters + accepts indented operands in ordinary statement + registers an offense and corrects correct + unrecognized style + registers an offense and corrects aligned code on LHS of equality operator + accepts indented operands in unless body + accepts indented operands in for body + registers an offense and corrects no indentation of second line + registers an offense and corrects emacs ruby-mode 1.1 indentation of an expression in an array + accepts two spaces indentation in assignment of local variable + accepts any indentation of parameters to #[] + accepts special indentation of for expression + registers an offense and corrects wrong indentation of for expression + accepts indented operands in an array + accepts unary operations + accepts any indentation of method parameters + registers an offense and corrects an unindented multiline operation that is the left operand in another operation + accepts indentation of next unless condition + accepts normal indentation inside grouped expression + registers an offense and corrects aligned operators in assignment + accepts indented operands in if condition + registers an offense and corrects three space indentation of second line + registers an offense and corrects one space indentation of second line + accepts indentation of next if condition + registers an offense for a 2 space indentation of if condition + does not check method calls + accepts an expression where the first operand spans multiple lines + accepts indentation of assignment + when indentation width is overridden for this cop + registers an offense and corrects + registers an offense for a 4 space indentation of unless condition + registers an offense for a 4 space indentation of while condition + accepts indented operands in if condition + accepts indented operands in while body + accepts indented operands in unless body + accepts indentation of while condition which is offset by a single normal indentation step + accepts indentation of if condition which is offset by a single normal indentation step + accepts indented operands in if body + registers an offense for a 4 space indentation of if condition + accepts indentation of unless condition which is offset by a single normal indentation step + accepts indentation of until condition which is offset by a single normal indentation step + accepts indented operands in until body + registers an offense for a 4 space indentation of until condition + when EnforcedStyle is aligned + accepts indented operands inside block + assignment + registers an offense and corrects no indentation of second line + accepts indented code on LHS of equality operator + registers an offense and corrects indented second part of string + registers an offense and corrects misaligned string operand when plus is used + registers an offense and corrects misaligned operands in unless condition + accepts aligned operands in if condition + accepts no extra indentation of third line + registers an offense and corrects indented operands in if condition + does not check method calls + registers an offense and corrects misaligned string operand when the first operand has backslash continuation + registers an offense and corrects one space indentation of second line + registers an offense and corrects three space indentation of second line + accepts an expression where the first operand spans multiple lines + registers an offense and corrects emacs ruby-mode 1.1 indentation of an expression in an array + registers an offense and corrects an unindented multiline operation that is the left operand in another operation + accepts indented operands in ordinary statement + registers an offense for misaligned operands in while condition + accepts any indentation of parameters to #[] + accepts indented operands with ternary operators + accepts two spaces indentation in assignment of array element + accepts indented operands inside and outside a block + accepts two spaces indentation in assignment of local variable + accepts alignment inside a grouped expression + accepts indented operands in an array + registers an offense for misaligned operands in if condition + accepts indented operands in for body + accepts aligned or:ed operands in assignment + accepts aligned operands in assignment + accepts two spaces indentation of second line + accepts unary operations + registers an offense for misaligned operands in unless condition + registers an offense and corrects indented operand in second argument + registers an offense and corrects extra indentation of third line + registers an offense and corrects unaligned operands in op-assignment + registers an offense for misaligned operands in until condition + +RuboCop::Cop::Badge + compares by value + exposes cop name + can be converted to a string with the Department/CopName format + exposes department name + .new + assigns department + assigns name + assigns name + assigns name + assigns department + assigns department + assigns name + assigns department + #camel_case + converts "foo_bar" to CamelCase + converts "lint" to CamelCase + converts "rspec" to CamelCase + .parse + parses identifier + parses identifier + parses identifier + parses identifier + parses identifier + parses identifier + #qualified? + says `Deep/Department/CopName` is qualified + says `CopName` is not qualified + says `Department/CopName` is qualified + .for + parses cop class name + parses cop class name + parses cop class name + parses cop class name + parses cop class name + +RuboCop::Cop::Layout::SpaceInsideRangeLiteral + accepts complex range literal with space in it + registers an offense for space inside ... literal + accepts multiline range literal with no space in it + accepts no space inside ... literal + registers an offense for space inside .. literal + registers an offense in multiline range literal with space in it + accepts no space inside .. literal + +RuboCop::Cop::Style::InPatternThen + >= Ruby 2.7 + registers an offense for `in b, c | d;` + accepts `;` separating statements in the body of `in` + registers an offense for `in b | c | d;` (alternative pattern) + registers an offense for `in b, c, d;` (array pattern) + registers an offense for `in b;` + when inspecting a case statement with an empty branch does not register an offense -RuboCop::Cop::Style::Attr - registers an offense attr - registers offense for attr within module_eval - accepts attr when it has a receiver - accepts attr when it does not take arguments - does not register offense for custom `attr` method - registers offense for attr within class_eval - autocorrects - attr with multiple names to attr_reader - attr to attr_reader - attr :name, true to attr_accessor :name - attr, false to attr_reader +RuboCop::Cop::Naming::VariableName + when configured for snake_case + registers an offense for camel case in instance variable name + registers an offense for camel case in class variable name + accepts assigning to camel case constant + registers an offense for camel case in local variable name + registers an offense for keyword arguments + accepts screaming snake case constants + registers an offense for camel case when invoking method args + registers an offense for rest arguments + accepts screaming snake case globals + registers an offense for default method arguments + registers an offense for correct + opposite + accepts one symbol size local variables + accepts assignment with indexing of self + registers an offense for method arguments + registers an offense for keyword rest arguments + registers an offense for camel case local variables marked as unused + accepts local variables marked as unused + registers an offense for block arguments + when AllowedIdentifiers is set + does not register an offense for a method name that is allowed + does not register an offense for a local variable name that is allowed + does not register an offense for a instance variable name that is allowed + does not register an offense for a class variable name that is allowed + does not register an offense for a symbol that is allowed + does not register an offense for a global variable name that is allowed + when AllowedPatterns is set + does not register an offense for a class variable name that matches the allowed pattern + does not register an offense for a method name that matches the allowed pattern + does not register an offense for a symbol that matches the allowed pattern + does not register an offense for a local variable name that matches the allowed pattern + does not register an offense for a instance variable name that matches the allowed pattern + does not register an offense for a global variable name that matches the allowed pattern + when configured for camelCase + accepts screaming snake case globals + accepts camel case local variables marked as unused + registers an offense for opposite + correct + registers an offense for keyword rest arguments + accepts one symbol size local variables + accepts assigning to camel case constant + registers an offense for block arguments + registers an offense for camel case when invoking method args + accepts local variables marked as unused + registers an offense for snake case in method parameter + registers an offense for default method arguments + accepts screaming snake case constants + accepts assignment with indexing of self + accepts with non-ascii characters + accepts camel case in local variable name + registers an offense for keyword arguments + accepts camel case in class variable name + registers an offense for snake case in local variable name + registers an offense for rest arguments + accepts camel case in instance variable name + when AllowedPatterns is set + does not register an offense for a symbol that matches the allowed pattern + does not register an offense for a global variable name that matches the allowed pattern + does not register an offense for a method name that matches the allowed pattern + does not register an offense for a class variable name that matches the allowed pattern + does not register an offense for a instance variable name that matches the allowed pattern + does not register an offense for a local variable name that matches the allowed pattern + when AllowedIdentifiers is set + does not register an offense for a method name that is allowed + does not register an offense for a global variable name that is allowed + does not register an offense for a symbol that is allowed + does not register an offense for a local variable name that is allowed + does not register an offense for a instance variable name that is allowed + does not register an offense for a class variable name that is allowed -RuboCop::Cop::Layout::ParameterAlignment - aligned with first parameter - registers an offense and corrects alignment in simple case - registers an offense and corrects parameters with single indent - accepts parameter lists on a single line - accepts proper indentation - accepts a method definition without parameters - doesn't get confused by splat - registers an offense and corrects parameters with double indent - accepts the first parameter being on a new row - defining self.method - registers an offense and corrects parameters with single indent - accepts proper indentation - aligned with fixed indentation - accepts the first parameter being on a new row - accepts proper indentation - doesn't get confused by splat - registers an offense and corrects parameters aligned to first param - accepts parameter lists on a single line - registers an offense and corrects parameters with double indent - accepts a method definition without parameters - defining self.method - accepts proper indentation - registers an offense and corrects parameters aligned to first param +RuboCop::Cop::Lint::MultipleComparison + registers an offense for x <= y <= z + registers an offense for x <= y >= z + accepts to use `|` operator + registers an offense for x > y > z + registers an offense for x > y < z + registers an offense for x <= y < z + registers an offense for x > y >= z + registers an offense for x >= y <= z + registers an offense for x < y < z + registers an offense for x < y >= z + registers an offense for x < y <= z + accepts to use `^` operator + registers an offense for x >= y < z + accepts to use `&` operator + accepts to use one compare operator + registers an offense for x >= y > z + registers an offense for x >= y >= z + registers an offense for x > y <= z + registers an offense for x <= y > z + registers an offense for x < y > z -RuboCop::Cop::Style::ParenthesesAroundCondition - allows parens if the condition node is a modifier unless op - does not blow up when the condition is a ternary op - does not register an offense when parentheses in multiple expressions separated by semicolon - allows parens if the condition node is a modifier if op - allows parens if the condition node is a modifier while op - does not blow up for empty if condition - accepts parentheses if there is no space between the keyword and (. - allows parens if the condition node is a modifier until op - is not confused by parentheses in subexpression - does not blow up for empty unless condition - accepts parentheses around condition in a ternary - registers an offense for parentheses around condition - is not confused by leading parentheses in subexpression - allows parens if the condition node is a modifier rescue op - safe assignment is allowed - accepts setter in condition surrounded with parentheses - accepts variable assignment in condition surrounded with parentheses - accepts element assignment in condition surrounded with parentheses - parentheses in multiline conditions are allowed - registers an offense for parentheses in single line condition - accepts parentheses around multiline condition - parentheses in multiline conditions are not allowed - registers an offense for parentheses around multiline condition - safe assignment is not allowed - does not accept variable assignment in condition surrounded with parentheses - does not accept element assignment in condition surrounded with parentheses +RuboCop::Cop::Style::InlineComment + does not register an offense for special rubocop inline comments + registers an offense for a trailing inline comment + does not register an offense for a standalone comment -RuboCop::Cop::Lint::PercentSymbolArray - detecting colons or commas in a %i/%I string - accepts tokens without colons or commas - registers an offense and corrects when there are no colons but one comma - accepts tokens without colons or commas - registers an offense and corrects when one symbol has a colon but there are no commas - registers an offense and corrects when one symbol has a colon but there are no commas - registers an offense and corrects when symbols contain colons and are comma separated - accepts likely false positive $, - registers an offense and corrects when there are no colons but one comma - registers an offense and corrects when symbols contain colons and are comma separated - accepts likely false positive $, - with binary encoded source - registers an offense and corrects when tokens contain quotes - accepts if tokens contain no quotes +RuboCop::Cop::InternalAffairs::NodeTypePredicate + does not register an offense for a predicate node type check + comparison node type check + registers an offense and autocorrects -RuboCop::Cop::Lint::TopLevelReturnWithArgument - Code segment with block level returns other than the top-level return - expects no offense from the return without arguments - expects offense from the return with arguments - Code segment with method-level return statements - expects offense when method-level & top-level return co-exist - Code segment with inline if along with top-level return - expects no offense from the return without arguments - expects multiple offense from the return with arguments - Code segment with only top-level return statement - expects no offense from the return without arguments - expects offense from the return with arguments - expects multiple offenses from the return with arguments statements - Code segment containing semi-colon separated statements - expects an offense from the return with arguments and multi-line code - expects no offense from the return with arguments and multi-line code +RuboCop::Cop::Style::ColonMethodCall + does not register an offense for Java static types + does not register an offense for constant access + does not register an offense for Java package namespaces + registers an offense for instance method call + registers an offense for instance method call with arg + does not register an offense for op methods + registers an offense for class method call + does not register an offense for nested class + registers an offense for class method call with arg + does not register an offense when for constructor methods -RuboCop::Cop::Metrics::ModuleLength - rejects a module with more than 5 lines - accepts a module with less than 5 lines - reports the correct beginning and end lines - accepts a module with 5 lines +RuboCop::Cop::Layout::SpaceBeforeFirstArg + for method calls without parentheses + registers an offense and corrects method call with two spaces before the first arg + accepts multiple space containing line break + registers an offense for method call with no spaces before the first arg + accepts setter call + accepts a method call with one space before the first arg + accepts + operator + when a vertical argument positions are aligned + registers an offense + when AllowForAlignment is false + registers an offense and corrects method calls with aligned first arguments + when AllowForAlignment is true + accepts method calls with aligned first arguments + when using safe navigation operator + registers an offense and corrects method call with two spaces before the first arg + for method calls with parentheses + accepts a method call with space after the left parenthesis + accepts a method call without space + +RuboCop::Cop::Style::Copyright + does not register an offense when the notice is not the first comment + does not register an offense when the notice is present + does not register an offense when the notice is in a block comment + when the copyright notice is missing and the source code file starts with an encoding comment + adds an offense + when the copyright notice is missing and the source code file starts with a shebang + adds an offense + when the copyright notice is missing and the source code file starts with shebang and an encoding comment + adds an offense + when the copyright notice comes after any code + adds an offense + when the source code file is empty + adds an offense + when the copyright notice is missing + adds an offense + fails to autocorrect when the AutocorrectNotice does not match the Notice pattern + fails to autocorrect if no AutocorrectNotice is given + +RuboCop::Cop::Layout::ElseAlignment + accepts a ternary if + with def/defs + accepts an empty def body + accepts an empty defs body + when modifier and def are on the same line + accepts a correctly aligned body + registers an offense for else not aligned with private + with def/rescue/else/end + registers an offense for misaligned else + accepts a correctly aligned else + with unless + registers an offense for misaligned else + accepts a correctly aligned else in an otherwise empty unless + accepts an empty unless + with begin/rescue/else/ensure/end + accepts a correctly aligned else + registers an offense for misaligned else + ensure/rescue/else in Block Argument + registers an offense for misaligned else + accepts a correctly aligned else + accepts a correctly aligned else with assignment + with if statement + accepts a correctly aligned if/elsif/else/end + registers an offense for misaligned else + registers an offense for misaligned elsif + accepts a one line if statement + accepts indentation after else when if is on new line after assignment + accepts an if/else branches with rescue clauses + with assignment + when alignment style is variable + and end is aligned with variable + accepts an if/else with chaining after the end + accepts an if/else with chaining with a block after the end + accepts an if-elsif-else with end aligned with setter + accepts an if/else + accepts an if with end aligned with element assignment + accepts an if-else with end aligned with setter + and end is aligned with keyword + registers an offense for an if + registers offenses for an if with setter + registers an offense for an if with element assignment + when alignment style is keyword by choice + and end is aligned with keyword + accepts an if/else in assignment on next line + accepts an if in assignment + accepts a while in assignment + accepts an until in assignment + accepts an if/else in assignment + and end is aligned with variable + registers an offense for an if + for a file with byte order mark + accepts a correctly aligned if/elsif/else/end + with def/rescue/else/ensure/end + registers an offense for misaligned else + accepts a correctly aligned else + with case + registers an offense for misaligned else + accepts else aligned with when but not with case + accepts case without else + accepts correctly aligned case/when/else + >= Ruby 2.7 + with case match + accepts correctly aligned empty else + accepts case match without else + accepts correctly aligned case/when/else + registers an offense for misaligned else + +RuboCop::Cop::Style::LambdaCall + when style is set to call + registers an offense for correct + multiple opposite styles + registers an offense for correct + opposite + registers an offense for x.() + when style is set to braces + registers an offense for x.call() + accepts a call without receiver + autocorrects x.call to x.() + autocorrects x.call asdf, x123 to x.(asdf, x123) + registers an offense for correct + multiple opposite styles + registers an offense for opposite + correct + +RuboCop::Cop::Layout::SingleLineBlockChain + does not register an offense for method call chained on a new line after a single line block with trailing dot + does not register an offense for method call chained on a new line after a single line block + does not register an offense for method call chained without a dot + registers an offense for method call chained on the same line as a block + does not register an offense for method call chained on the same line as a multiline block + registers an offense for no selector method call chained on the same line as a block + +RuboCop::Cop::Style::RedundantFileExtensionInRequire + does not register an offense when requiring variable as a filename + does not register an offense when requiring filename ending with `.so` + does not register an offense when requiring filename without an extension + registers an offense and corrects when requiring filename ending with `.rb` + +RuboCop::Cop::Layout::ArrayAlignment + when aligned with first parameter + autocorrects array within array with too much indentation + accepts several elements per line + autocorrects array within array with too little indentation + accepts aligned array keys + accepts the first element being on a new row + does not indent heredoc strings when autocorrecting + accepts single line array + does not register an offense or try to correct parallel assignment + autocorrects misaligned array with the first element on a new row + accepts aligned array with fullwidth characters + registers an offense and corrects misaligned array elements + when aligned with fixed indentation + accepts single line array + autocorrects array within array with too much indentation + registers an offense and corrects misaligned array elements + does not indent heredoc strings when autocorrecting + accepts several elements per line + accepts aligned array with fullwidth characters + autocorrects array within array with too little indentation + does not register an offense or try to correct parallel assignment + autocorrects misaligned array with the first element on a new row + accepts aligned array keys + accepts the first element being on a new row + +RuboCop::Cop::Layout::ClosingParenthesisIndentation + accepts begin nodes that are not grouped expressions + for method assignments with indented parameters + with no line break before 1st parameter + accepts a correctly aligned ) + can handle hash arguments that are not broken over lines + can handle inner method calls + accepts a correctly indented ) + can handle indentation up against the left edge + registers an offense for misaligned ) + can handle individual arguments that are broken over lines + with line break before 1st parameter + registers an offense for misaligned ) + accepts a correctly aligned ) + without arguments + can handle indentation up against the method + can handle indentation up against the left edge + registers an offense for misaligned ) + accepts a correctly aligned ) against ( + accepts empty () + for method chains + can handle multiple chains with differing breaks + registers an offense and corrects method chains + when using safe navigation operator + registers an offense and corrects misaligned ) + for grouped expressions + with no line break before 1st operand + accepts a correctly aligned ) + accepts ) that does not begin its line + registers an offense for misaligned ) + with line break before 1st operand + registers an offense for misaligned ) + accepts a correctly aligned ) + for method calls + with no line break before 1st parameter + registers an offense and corrects misindented ) when ) is aligned with the params + accepts a correctly aligned ) + does not register an offense when using keyword arguments + accepts a correctly indented ) inside a block + registers an offense for misaligned ) + accepts a correctly indented ) + with first multiline arg on new line + accepts ) on the same level as ( with args on same line + accepts ) on the same level as ( with second arg on new line + with line break before 1st parameter + accepts a correctly aligned ) + registers an offense for misaligned ) + without arguments + accepts empty () + accepts a correctly aligned ) against ( + can handle indentation up against the left edge + for method definitions + with no line break before 1st parameter + accepts empty () + accepts a correctly aligned ) + registers an offense for misaligned ) + with line break before 1st parameter + registers an offense for misaligned ) + accepts a correctly aligned ) + +RuboCop::Cop::Metrics::ClassLength + accepts empty classes + accepts a class with less than 5 lines + rejects a class with more than 5 lines does not count blank lines - accepts empty modules - when inspecting a class defined with Module.new + accepts a class with 5 lines + reports the correct beginning and end lines + when a class has inner classes + rejects a class with 6 lines that belong to the class directly + does not count lines of inner classes + when inspecting a class defined with Struct.new + registers an offense when multiple assignments to constants + registers an offense when inspecting or equals (`||=`) for constant registers an offense - when inspecting a class defined with ::Module.new + when inspecting a class defined with Class.new registers an offense + when overlapping constant assignments + does not register an offense when CountComments is enabled + registers an offense for a class that only contains comments also counts commented lines - when a module has inner modules - does not count lines of inner modules - rejects a module with 6 lines that belong to the module directly when using numbered parameter - when inspecting a class defined with ::Module.new + when inspecting a class defined with Struct.new + registers an offense when inspecting or equals (`||=`) for constant + registers an offense when multiple assignments to constants registers an offense - when inspecting a class defined with Module.new + when inspecting a class defined with ::Class.new registers an offense - when a module has inner classes - rejects a module with 6 lines that belong to the module directly - does not count lines of inner classes + when inspecting a class defined with Class.new + registers an offense + when inspecting a class defined with ::Class.new + registers an offense when `CountAsOne` is not empty folds array into one line + when CountComments is disabled + accepts classes that only contain comments RuboCop::Cop::Layout::SpaceAroundOperators - accepts operator symbols - accepts an assignment followed by newline - accepts an assignment with the same alignment margins - accepts []= without space - accepts exclamation point definition accepts operators with spaces accepts [arg] without space - accepts argument default values without space - accepts an operator at the end of a line - registers an offenses for exponent operator with spaces - accepts an assignment with spaces - accepts some operators that are exceptions & don't need spaces + accepts unary operators without space + accepts a unary accepts [] without space + accepts []= without space + accepts rational accepts ranges - accepts def of operator - accepts an assignment with a blank line accepts ::Kernel::raise - accepts a unary + accepts exclamation point definition + accepts argument default values without space + accepts splat operator + registers an offense and corrects singleton class operator` + accepts an assignment by `for` statement accepts scope operator - accepts rational + accepts an assignment followed by newline accepts an operator at the beginning of a line - accepts an operator called with method syntax - accepts splat operator + accepts the result of the ExtraSpacing Cop accepts exponent operator without spaces + registers an offenses for exponent operator with spaces + accepts an operator at the end of a line + accepts def of operator registers an offense and corrects exclamation point negation - registers an offense and corrects singleton class operator` - accepts the result of the ExtraSpacing Cop - accepts an assignment by `for` statement + accepts an assignment with spaces + accepts an assignment with a blank line accepts operator surrounded by tabs - accepts unary operators without space - >= Ruby 2.7 - does not register an offenses for one-line pattern matching syntax (`in`) + accepts an assignment with the same alignment margins + accepts operator symbols + accepts an operator called with method syntax + accepts some operators that are exceptions & don't need spaces >= Ruby 3.0 registers an offenses for one-line pattern matching syntax (`=>`) - when EnforcedStyleForExponentOperator is space - registers an offenses for exponent operator without spaces extra space around operators - registers an offense and corrects assignment with too many spaces on either side - registers an offense and corrects binary operators that could be unary - registers an offense and corrects inheritance < with too many spaces - does not register an offenses match operators between `+=` and `<<` - registers an offense and corrects hash rocket with too many spaces at rescue - registers an offense and corrects a hash rocket with an extra spaceon multiple line - registers an offense and corrects arguments to a method - registers an offense and corrects `-` with too many spaces with negative lhs operand - accepts for a hash rocket with an extra space for alignment on multiple line registers an offense and corrects operators with too many spaces - registers an offense and corrects match operators with too many spaces - registers an offense and corrects ternary operator with too many spaces + registers an offense and corrects a setter call with too many spaces + registers an offense and corrects a hash rocket with an extra spaceon multiple line registers an offense and corrects various assignments with too many spaces - does not register an offenses match operators between `<<` and `+=` + registers an offense and corrects ternary operator with too many spaces + does not register an offenses match operators between `+=` and `<<` + registers an offense and corrects hash rocket with too many spaces at rescue registers an offense and corrects a hash rocket with too many spaces + registers an offense and corrects binary operators that could be unary registers an offense and corrects operators with too many spaces on the same line - registers an offense and corrects a setter call with too many spaces + registers an offense and corrects assignment with too many spaces on either side registers an offense and corrects equality operators with too many spaces + registers an offense and corrects match operators with too many spaces + registers an offense and corrects inheritance < with too many spaces + does not register an offenses match operators between `<<` and `+=` + registers an offense and corrects arguments to a method + accepts for a hash rocket with an extra space for alignment on multiple line + registers an offense and corrects `-` with too many spaces with negative lhs operand + when does not allowed for alignment + registers an offense and corrects an extra space behaves like modifier with extra space - registers an offense in presence of modifier unless statement - behaves like modifier with extra space - registers an offense in presence of modifier while statement + registers an offense in presence of modifier until statement behaves like modifier with extra space registers an offense in presence of modifier if statement behaves like modifier with extra space - registers an offense in presence of modifier until statement - when does not allowed for alignment - registers an offense and corrects an extra space - when Layout/ExtraSpacing has `ForceEqualSignAlignment` configured to true - allows constants to be aligned - allows variables to be aligned + registers an offense in presence of modifier unless statement + behaves like modifier with extra space + registers an offense in presence of modifier while statement missing space around operators - registers an offense and corrects match operators without space - registers an offense for operators without spaces - registers an offense and corrects equality operators without space - registers an offense and corrects various assignments without space + registers an offense and corrects arguments to a method + registers an offense and corrects string concatenation without messing up new lines registers an offense for binary operators that could be unary registers an offense for assignment without space on both sides - doesn't register an offense for operators with newline on right + registers an offense and corrects `-` without space with a negative lhs operand registers an offense and corrects a setter call without spaces - registers an offense and corrects string concatenation without messing up new lines registers an offense and corrects inheritance < without space - registers an offense and corrects `-` without space with a negative lhs operand - registers an offense and corrects arguments to a method + registers an offense and corrects match operators without space + doesn't register an offense for operators with newline on right + registers an offense and corrects various assignments without space + registers an offense and corrects equality operators without space + registers an offense for operators without spaces registers an offense and corrects hash rocket without space at rescue behaves like modifier with missing space - registers an offense in presence of modifier unless statement + registers an offense in presence of modifier if statement + behaves like modifier with missing space + registers an offense in presence of modifier until statement + when a hash literal is on multiple lines + and Layout/HashAlignment:EnforcedHashRocketStyle is table + doesn't register an offense for a hash rocket without spaces + and Layout/HashAlignment:EnforcedHashRocketStyle is key + registers an offense and corrects a hash rocket without spaces + behaves like modifier with missing space + registers an offense in presence of modifier while statement when a hash literal is on a single line and Layout/HashAlignment:EnforcedHashRocketStyle is key registers an offense and corrects a hash rocket without spaces and Layout/HashAlignment:EnforcedHashRocketStyle is table registers an offense and corrects a hash rocket without spaces - behaves like modifier with missing space - registers an offense in presence of modifier if statement ternary operators - registers an offense and corrects operators with just a trailing space registers an offense and corrects operators with just a leading space registers an offense and corrects operators with no spaces - when a hash literal is on multiple lines - and Layout/HashAlignment:EnforcedHashRocketStyle is table - doesn't register an offense for a hash rocket without spaces - and Layout/HashAlignment:EnforcedHashRocketStyle is key - registers an offense and corrects a hash rocket without spaces - behaves like modifier with missing space - registers an offense in presence of modifier until statement + registers an offense and corrects operators with just a trailing space behaves like modifier with missing space - registers an offense in presence of modifier while statement - -RuboCop::Cop::Lint::AssignmentInCondition - registers an offense for assignment after == in condition - accepts == in condition - registers an offense for collection element assignment in condition - registers an offense for clvar assignment in condition - registers an offense for assignment methods - registers an offense for lvar assignment in while condition - accepts = in a block followed by method call - registers an offense for = in condition inside a block - accepts assignment in a block after || - accepts ||= in condition - registers an offense for assignment after ||= in condition - accepts = in a block that is called in a condition - registers an offense for gvar assignment in condition - registers an offense for lvar assignment in condition - registers an offense for lvar assignment in until condition - registers an offense for constant assignment in condition - does not blow up for empty if condition - does not blow up for empty unless condition - registers an offense for ivar assignment in condition - safe assignment is allowed - accepts = in condition surrounded with braces - accepts []= in condition surrounded with braces - safe assignment is not allowed - does not accept = in condition surrounded with braces - does not accept []= in condition surrounded with braces - -RuboCop::Cop::Layout::EndAlignment - registers an offense for mismatched puts 1; unless test end and autocorrects - can handle ternary if - registers an offense for mismatched case a when b end and autocorrects - accepts matching case ... end - accepts matching puts 1; if ... end - accepts matching class ... end - accepts matching puts 1; module ... end - registers an offense for mismatched module Test end and autocorrects - accepts matching puts 1; class ... end - accepts matching puts 1; until ... end - accepts matching until ... end - accepts matching puts 1; while ... end - accepts matching while ... end - registers an offense for mismatched if test end and autocorrects - accepts matching unless ... end - registers an offense for mismatched puts 1; class Test end and autocorrects - registers an offense for mismatched puts 1; while test end and autocorrects - registers an offense for mismatched while test end and autocorrects - registers an offense for mismatched puts 1; class Test end and autocorrects - registers an offense for mismatched module Test end and autocorrects - registers an offense for mismatched until test end and autocorrects - accepts matching class ... end - registers an offense for mismatched puts 1; until test end and autocorrects - accepts matching puts 1; case ... end - registers an offense for mismatched puts 1; case a when b end and autocorrects - can handle modifier if - registers an offense for mismatched puts 1; if test end and autocorrects - accepts matching module ... end - accepts matching puts 1; unless ... end - accepts matching if ... end - registers an offense for mismatched unless test end and autocorrects - when EnforcedStyleAlignWith is start_of_line - registers an offense for mismatched var << case a when b end and autocorrects - accepts matching puts 1; if ... end - registers an offense for mismatched puts 1; if test end and autocorrects - registers an offense for mismatched var = while test end and autocorrects - registers an offense for mismatched var = if test end and autocorrects - accepts matching var = if ... end - accepts matching var = if ... end - registers an offense for mismatched var << while test end and autocorrects - accepts matching puts 1; while ... end - registers an offense for mismatched var = until test end and autocorrects - registers an offense for mismatched puts 1; until test end and autocorrects - registers an offense for mismatched puts 1; unless test end and autocorrects - registers an offense for mismatched puts 1; class Test end and autocorrects - registers an offense for mismatched puts 1; case a when b end and autocorrects - accepts matching var = case ... end - registers an offense for mismatched module Test end and autocorrects - registers an offense for mismatched var = case a when b end and autocorrects - registers an offense for mismatched until test end and autocorrects - registers an offense for mismatched class Test end and autocorrects - accepts matching puts 1; unless ... end - registers an offense for mismatched puts 1; while test end and autocorrects - accepts matching var = until ... end - accepts matching puts 1; module ... end - registers an offense for mismatched var = unless test end and autocorrects - registers an offense for mismatched if test end and autocorrects - registers an offense for mismatched var << unless test end and autocorrects - registers an offense for mismatched puts 1; module Test end and autocorrects - registers an offense for mismatched var << until test end and autocorrects - registers an offense for mismatched puts(if test end) and autocorrects - accepts matching puts 1; class ... end - accepts matching var = while ... end - accepts matching var << while ... end - registers an offense for mismatched while test end and autocorrects - registers an offense for mismatched case a when b end and autocorrects - registers an offense for mismatched var = if test end and autocorrects - registers an offense for mismatched unless test end and autocorrects - accepts matching puts 1; case ... end - accepts matching var = unless ... end - registers an offense for mismatched var << if test end and autocorrects - accepts matching puts 1; until ... end - correct + opposite - registers an offense and corrects - regarding assignment - when EnforcedStyleAlignWith is keyword - registers an offense for mismatched var = unless test end and autocorrects - registers an offense for mismatched var = until test end and autocorrects - registers an offense for mismatched var << until test end and autocorrects - accepts matching var = unless ... end - accepts matching var[0] = case ... end - accepts matching var = until ... end - registers an offense for mismatched var = if test end and autocorrects - accepts matching var = while ... end - accepts matching var = case ... end - accepts matching var = if ... end - registers an offense for mismatched var = while test end and autocorrects - when EnforcedStyleAlignWith is variable - registers an offense for mismatched CNST << if test end and autocorrects - accepts matching var = while ... end - accepts matching h.k = if ... end - accepts matching @@var = if ... end - accepts matching var &&= if ... end - registers an offense for mismatched var &&= if test end and autocorrects - registers an offense for mismatched var << case a when b end and autocorrects - registers an offense for mismatched var = while test end and autocorrects - accepts matching var = until ... end - accepts matching h[k] = if ... end - accepts matching @var = if ... end - registers an offense for mismatched var = until test end and autocorrects - registers an offense for mismatched var << until test end and autocorrects - accepts matching var = case ... end - accepts matching var = unless ... end - registers an offense for mismatched $var = if test end and autocorrects - registers an offense for mismatched $var << if test end and autocorrects - registers an offense for mismatched var ||= if test end and autocorrects - registers an offense for mismatched a, b = if test end and autocorrects - accepts matching var = until ... end - accepts matching $var = if ... end - accepts matching var = until ... end - registers an offense for mismatched var[x] = while test end and autocorrects - accepts matching var = if ... end - accepts matching CNST = if ... end - accepts matching var += if ... end - registers an offense for mismatched var += if test end and autocorrects - accepts matching var ||= if ... end - registers an offense for mismatched @var << if test end and autocorrects - registers an offense for mismatched h[k] = if test end and autocorrects - registers an offense for mismatched var = unless test end and autocorrects - registers an offense for mismatched var = # comment while test end and autocorrects - registers an offense for mismatched CNST = if test end and autocorrects - registers an offense for mismatched var = unless test end and autocorrects - registers an offense for mismatched @@var = if test end and autocorrects - registers an offense for mismatched var << unless test end and autocorrects - registers an offense for mismatched var = until test do_something end and autocorrects - registers an offense for mismatched h[k] << if test end and autocorrects - accepts matching var << if ... end - registers an offense for mismatched var = until test end.j and autocorrects - accepts matching var = if ... end - registers an offense for mismatched @var = if test end and autocorrects - registers an offense for mismatched h.k = if test end and autocorrects - registers an offense for mismatched var = if test end and autocorrects - registers an offense for mismatched @@var << if test end and autocorrects - accepts matching a, b = if ... end - registers an offense for mismatched var = if test end and autocorrects - registers an offense for mismatched var = case a when b end and autocorrects - registers an offense for mismatched var << if test end and autocorrects - when EnforcedStyleAlignWith is variable - registers an offense for mismatched puts 1; case a when b end and autocorrects - registers an offense for mismatched puts 1; if test end and autocorrects - accepts matching until ... end - accepts matching class ... end - accepts matching while ... end - accepts matching puts 1; case ... end - register an offense when using a conditional statement in a method argument and `end` is not aligned - accepts matching puts 1; if ... end - register an offense when using `-` operator method and `end` is not aligned - registers an offense for mismatched if test end and autocorrects - register an offense when using `+` operator method and `end` is not aligned - registers an offense for mismatched puts 1; module Test end and autocorrects - accepts matching puts 1; class ... end - accepts matching puts 1; until ... end - accepts matching puts 1; unless ... end - accepts matching puts 1; module ... end - registers an offense for mismatched case a when b end and autocorrects - registers an offense for mismatched puts 1; class Test end and autocorrects - registers an offense for mismatched puts 1; unless test end and autocorrects - accepts matching if ... end - accepts matching unless ... end - registers an offense for mismatched class Test end and autocorrects - accepts matching module ... end - registers an offense for mismatched puts 1; until test end and autocorrects - registers an offense for mismatched puts 1; while test end and autocorrects - registers an offense for mismatched unless test end and autocorrects - registers an offense for mismatched module Test end and autocorrects - registers an offense for mismatched until test end and autocorrects - accepts matching puts 1; while ... end - accepts matching case ... end - registers an offense for mismatched while test end and autocorrects - case as argument - when EnforcedStyleAlignWith is keyword - accepts matching test case ... end - registers an offense for mismatched test case a when b end and autocorrects - when EnforcedStyleAlignWith is variable - accepts matching test case ... end - registers an offense for mismatched test case a when b end and autocorrects - when EnforcedStyleAlignWith is start_of_line - accepts matching test case a when b ... end - registers an offense for mismatched test case a when b end and autocorrects - when end is preceded by something else than whitespace - does not register an offense - -RuboCop::Cop::Style::ClassEqualityComparison - registers an offense and corrects when comparing class using `==` for equality - registers an offense and corrects when comparing single quoted class name for equality - registers an offense and corrects when comparing `Module#name` for equality - does not register an offense when using `instance_of?` - registers an offense and corrects when comparing double quoted class name for equality - registers an offense and corrects when comparing class using `eql?` for equality - registers an offense and corrects when comparing class using `equal?` for equality - with String comparison in module - registers and corrects an offense - with instance variable comparison in module - registers and corrects an offense - when AllowedMethods is enabled - does not register an offense when comparing class for equality - when AllowedPatterns is enabled - does not register an offense when comparing class for equality + registers an offense in presence of modifier unless statement + when Layout/ExtraSpacing has `ForceEqualSignAlignment` configured to true + allows constants to be aligned + allows variables to be aligned + when EnforcedStyleForExponentOperator is space + registers an offenses for exponent operator without spaces + >= Ruby 2.7 + does not register an offenses for one-line pattern matching syntax (`in`) -RuboCop::Cop::InternalAffairs::RedundantLetRuboCopConfigNew - registers an offense when using `let(:config)` with no argument `RuboCop::Config.new` and `:config` is specified - registers an offense when using `let(:config)` and `:config` is not specified in `describe` - registers an offense when using `let(:config)` and `:config` is already specified in `describe` - does not register an offense when using `let(:config)` with arguments to `RuboCop::Config.new` +RuboCop::Cop::Style::NumberedParameters + >= Ruby 2.7 + EnforcedStyle: allow_single_line + registers an offense when using numbered parameters with multi-line blocks + does not register an offense when using numbered parameters with single-line blocks + EnforcedStyle: disallow + does an offense when using numbered parameters even with single-line blocks -RuboCop::Cop::Lint::EmptyEnsure - does not register an offense for non-empty ensure - registers an offense and corrects empty ensure +RuboCop::CLI --disable-uncorrectable + --disable-uncorrectable + does not disable anything for cops that support autocorrect + if one one-line disable statement fits + adds it + adds it when the cop supports autocorrect but does not correct the offense + but there are more offenses on the line and they don't all fit + adds both one-line and before-and-after disable statements + and there are two offenses of the same kind on one line + adds a single one-line disable statement + when exist offense for Layout/SpaceInsideArrayLiteralBrackets + when `EnforcedStyle: no_space` + does not disable anything for cops that support autocorrect + when `EnforcedStyle: space` + does not disable anything for cops that support autocorrect + if a one-line disable statement doesn't fit + adds before-and-after disable statement + and the offense is inside a heredoc + adds before-and-after disable statement around the heredoc -RuboCop::Cop::Style::TopLevelMethodDefinition - does not register an offense when using class - registers an offense top-level methods - does not register an offense when using Struct - does not register an offense when just called method on top-level - does not register an offense when using module - registers an offense when defining a top-level method after a class definition - does not register an offense when defined within arbitrary block - does not register an offense when define_method is not top-level - registers an offense top-level class methods - top-level define_method - registers offense for proc argument - registers offense for multi-line block - registers offense with inline block +RuboCop::Cop::Style::DoubleNegation + when `EnforcedStyle: forbidden` + does not register an offense for ! + registers an offense and corrects for `!!` + registers an offense for `!!` when return location and using `rescue` + does not register an offense for `not not` + registers an offense for `!!` when return location and using `rescue` and `ensure` + registers an offense and corrects for `!!` when using `return` keyword + registers an offense for `!!` when return location and using `rescue`, `else`, and `ensure` + registers an offense and corrects for `!!` when return location + registers an offense and corrects for `!!` when not a return location + registers an offense for `!!` when return location and using `ensure` + when `EnforcedStyle: allowed_in_returns` + does not register an offense for `!!` when return location and using `rescue`, `else`, and `ensure` + registers an offense and corrects for `!!` + does not register an offense for `!!` when using `return` keyword + registers an offense and corrects for `!!` when not return location and using `unless` + registers an offense and corrects for `!!` with array when not return locationand using `if`, `elsif`, and `else` + does not register an offense for `!!` when return location and using `rescue` and `ensure` + does not register an offense for ! + registers an offense and corrects for `!!` when not a return location + does not register an offense for `not not` + registers an offense and corrects for `!!` with single-line hash at return location + registers an offense and corrects for `!!` with single-line array at return location + registers an offense and corrects for `!!` with hash when not return locationand using `if`, `elsif`, and `else` + registers an offense and corrects for `!!` with nested hash at return location + registers an offense and corrects for `!!` with multi-line hash at return location + registers an offense and corrects for `!!` when not return locationand using `if`, `elsif`, and `else` + does not register an offense for `!!` with hash when return location and using `case`, `when`, and `else` + registers an offense and corrects for `!!` when not return locationand using `case`, `when`, and `else` + does not register an offense for `!!` with array when return location and using `case`, `when`, and `else` + registers an offense and corrects for `!!` with complex array at return location + does not register an offense for `!!` when return location + registers an offense and corrects for `!!` with nested array at return location + does not register an offense for `!!` when return location and using `ensure` + does not register an offense for `!!` with array when return location and using `if`, `elsif`, and `else` + does not register an offense for `!!` when return location and using `if`, `elsif`, and `else` + registers an offense and corrects for `!!` with hash when not return locationand using `case`, `when`, and `else` + registers an offense and corrects for `!!` with multi-line array at return location + does not register an offense for `!!` with hash when return location and using `if`, `elsif`, and `else` + registers an offense and corrects for `!!` with array when not return locationand using `case`, `when`, and `else` + does not register an offense for `!!` when return location and using `rescue` + does not register an offense for `!!` when return location and using `case`, `when`, and `else` + does not register an offense for `!!` when return location by `define_method` + does not register an offense for `!!` when return location and using `unless` + does not register an offense for `!!` when return location by `define_singleton_method` Ruby >= 2.7 - registers offense with inline numblock - -RuboCop::Cop::Security::IoMethods - when using `IO` receiver and variable argument - registers and corrects an offense when using `foreach` - behaves like offense - registers and corrects an offense when using `readlines` - behaves like offense - registers and corrects an offense when using `write` - behaves like offense - registers and corrects an offense when using `binread` - behaves like offense - registers and corrects an offense when using `binwrite` - behaves like offense - registers and corrects an offense when using `read` - when using `IO` receiver and string argument that starts with a pipe character (`"| command"`) - behaves like accepts - does not register an offense when using `IO.binwrite("| command", "hi")` - behaves like accepts - does not register an offense when using `IO.foreach("| command") { |x| puts x }` - behaves like accepts - does not register an offense when using `IO.read("| command")` - behaves like accepts - does not register an offense when using `IO.write("| command", "hi")` - behaves like accepts - does not register an offense when using `IO.readlines("| command")` - when using `IO` receiver and string argument - registers and corrects an offense when using `foreach` - behaves like offense - registers and corrects an offense when using `readlines` - behaves like offense - registers and corrects an offense when using `write` - behaves like offense - registers and corrects an offense when using `binwrite` - behaves like offense - registers and corrects an offense when using `binwrite` - behaves like offense - registers and corrects an offense when using `read` - when using no receiver - behaves like accepts - does not register an offense when using `readlines("command")` - behaves like accepts - does not register an offense when using `write("command", "hi")` - behaves like accepts - does not register an offense when using `read("command")` - behaves like accepts - does not register an offense when using `binwrite("command", "hi")` - behaves like accepts - does not register an offense when using `foreach("command") { |x| puts x }` - when using `File` receiver - behaves like accepts - does not register an offense when using `File.binread(path)` - behaves like accepts - does not register an offense when using `File.foreach(path) { |x| puts x }` - behaves like accepts - does not register an offense when using `File.read(path)` - behaves like accepts - does not register an offense when using `File.binwrite(path, "hi")` - behaves like accepts - does not register an offense when using `File.readlines(path)` - when using `IO` receiver and string argument that starts with a pipe character (`" | command"`) - behaves like accepts - does not register an offense when using `IO.foreach(" | command") { |x| puts x }` - behaves like accepts - does not register an offense when using `IO.read(" | command")` - behaves like accepts - does not register an offense when using `IO.write(" | command", "hi")` - behaves like accepts - does not register an offense when using `IO.readlines(" | command")` - behaves like accepts - does not register an offense when using `IO.binwrite(" | command", "hi")` - -RuboCop::Cop::Style::TrailingBodyOnMethodDefinition - registers when body starts on def line & continues one more line - registers when body starts on def line & continues many more lines - autocorrects with comment after body - autocorrects body with method definition with args not in parens - does not register offense with trailing body on method end - accepts a method with multiple lines of body - accepts a method with one line of body - removes semicolon from method definition but not body when autocorrecting - registers an offense when body trails after method definition - when method is not on first line of processed_source - autocorrects offense - Ruby 3.0 or higher - does not register offense when endless method definition body is after newline in opening parenthesis - -RuboCop::Cop::Corrector - #rewrite - allows insertion before a source range - raises a useful error if not given a node or a range - allows removal of characters from range beginning - allows removal of a range - allows insertion after a source range - accepts a node instead of a range - allows removal of characters from range ending - allows insertion before and after a source range - allows replacement of a range - allows removal of characters preceding range - when range is from incorrect source - raises exception from remove_preceding - raises exception from remove_leading - raises exception from remove_trailing - raises exception from remove - raises exception from insert_before - raises exception from insert_after - raises exception from replace + does not register an offense for `!!` when return location and using `case`, `in`, and `else` + Ruby >= 2.7 + registers an offense and corrects for `!!` when not return locationand using `case`, `in`, and `else` -RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets - does not register offense for any kind of reference brackets - when EnforcedStyle is compact - registers an offense and corrects 3-dimensional array with extra spaces - does not register offense for valid 3-dimensional array - does not register offense for valid 4-dimensional array - does not register offense for valid 2-dimensional array - registers an offense and corrects 2-dimensional array with extra spaces - registers an offense and corrects space between 2 opening brackets - accepts multiline array - registers an offense and corrects space between 2 closing brackets - multiline, 2-dimensional array with newlines - registers an offense and corrects at the end of array - registers an offense and corrects at the beginning of array - multiline, 2-dimensional array with spaces - registers an offense and corrects at the end of array - registers an offense and corrects at the beginning of array - behaves like space inside arrays - register an offense and corrects when 2 arrays are on one line - does not register offense for arrays with spaces - registers an offense and corrects multiline array on end bracket with trailing method - accepts space inside array brackets with comment - does not register offense for valid multiline array - does not register offense for indented array when bottom bracket gets its own line & is misaligned - registers an offense and corrects multiline array on end bracket - does not register offense for array when brackets get their own line - does not register offense when 2 arrays on one line - does not register offense when bottom bracket gets its own line & has trailing method - accepts square brackets called with method call syntax - does not register offense for arrays using ref brackets - registers an offense and corrects array brackets with no trailing whitespace - registers an offense and corrects array brackets with no leading whitespace - registers an offense and corrects an array missing whitespace when there is more than one array on a line - accepts square brackets as method name - with space inside empty braces allowed - registers an offense and corrects empty brackets with no space inside - accepts empty brackets with space inside - registers an offense and corrects empty brackets with more than one space inside - when EnforcedStyle is no_space - does not register offense when bottom bracket gets its own line indented with tabs - registers an offense and corrects multiline array on end bracket with trailing method - accepts a multiline array with whitespace before end bracket - registers an offense and corrects an array literal as an argument with trailing whitespace after a heredoc is started - does not register offense when 2 arrays on one line - does not register offense for valid multiline array - accepts square brackets as method name - registers an offense and corrects 2 arrays on one line - does not register offense for valid 2-dimensional array - registers an offense and corrects array brackets with trailing whitespace - does not register offense when contains an array literal as an argument after a heredoc is started - registers an offense and corrects an array when two on one line - does not register offense for arrays with no spaces - registers an offense and corrects multiline array on end bracket - does not register offense when bottom bracket gets its own line & has trailing method - does not register offense for array when brackets get own line - does not register offense for indented array when bottom bracket gets its own line & is misaligned - does not register offense for arrays using ref brackets - registers an offense and corrects array brackets with leading whitespace - accepts square brackets called with method call syntax - accepts space inside array brackets if with comment - with space inside empty brackets not allowed - registers an offense and corrects multiline spaces - accepts empty brackets with no space inside - registers an offense and corrects empty brackets with 1 space inside - registers an offense and corrects empty brackets with multiple spaces inside - when EnforcedStyle is space - does not register offense for valid 2-dimensional array - behaves like space inside arrays - accepts square brackets as method name - does not register offense for arrays with spaces - does not register offense when 2 arrays on one line - does not register offense for arrays using ref brackets - does not register offense when bottom bracket gets its own line & has trailing method - accepts square brackets called with method call syntax - registers an offense and corrects array brackets with no trailing whitespace - registers an offense and corrects an array missing whitespace when there is more than one array on a line - does not register offense for valid multiline array - registers an offense and corrects multiline array on end bracket with trailing method - registers an offense and corrects multiline array on end bracket - registers an offense and corrects array brackets with no leading whitespace - does not register offense for array when brackets get their own line - register an offense and corrects when 2 arrays are on one line - does not register offense for indented array when bottom bracket gets its own line & is misaligned - accepts space inside array brackets with comment +RuboCop::Cop::Lint::HeredocMethodCallPosition + correct cases + accepts chained correct case + ignores if no call + accepts simple correct case + incorrect cases + chained case with multiple line args + detects + simple incorrect case + detects + chained case without args + detects + chained case no parens + detects + with trailing comma in method call + detects + chained case with parens + detects + simple incorrect case with paren + detects -RuboCop::Cop::Lint::LiteralAsCondition - registers an offense for literal :sym in complex ! - registers an offense for literal :sym in && - registers an offense for literal :"#{a}" in complex cond - registers an offense for literal [1] in if - accepts literal [1] in non-toplevel and/or - registers an offense for literal {} in && - registers an offense for case with a primitive array condition - registers an offense for literal {} in until - accepts `true` literal in post-loop `while` - registers an offense for `!1` - registers an offense for literal :sym in post-loop while - accepts literal {} in non-toplevel and/or - registers an offense for literal 2.0 in case - accepts `true` literal in `while` - registers an offense for literal [1] in post-loop while - registers an offense for literal {} in a when of a case without anything after case keyword - registers an offense for literal 1 in if - accepts literal :"#{a}" if it's not an and/or operand - registers an offense for literal :"#{a}" in && - registers an offense for literal 1 in && - registers an offense for literal [1] in until - registers an offense for literal 2.0 in && - registers an offense for literal 1 in post-loop until - registers an offense for literal :sym in a when of a case without anything after case keyword - registers an offense for literal 2.0 in complex cond - accepts literal [1] if it's not an and/or operand - registers an offense for literal :sym in post-loop until - registers an offense for literal {} in post-loop until - registers an offense for `not [1]` - registers an offense for literal :"#{a}" in complex ! - registers an offense for literal [1] in && - accepts array literal in case, if it has nested non-literal element - registers an offense for literal 1 in complex ! - registers an offense for `not :sym` - registers an offense for literal :sym in ! - registers an offense for literal 1 in while - registers an offense for literal :"#{a}" in case - registers an offense for literal 1 in until - registers an offense for `not :"#{a}"` - accepts literal 1 in a when of a case with something after case keyword - registers an offense for literal :sym in if - registers an offense for literal {} in complex cond - registers an offense for literal [1] in complex ! - registers an offense for literal {} in if - registers an offense for `not 1` - registers an offense for literal :"#{a}" in post-loop while - accepts array literal in case, if it has non-literal elements - registers an offense for literal 1 in case - registers an offense for literal [1] in complex cond - accepts literal {} if it's not an and/or operand - registers an offense for literal :sym in until - registers an offense for `!:"#{a}"` - registers an offense for literal {} in case - registers an offense for `!{}` - registers an offense for `not 2.0` - registers an offense for literal {} in ! - registers an offense for literal :"#{a}" in while - registers an offense for literal [1] in post-loop until - accepts literal {} in a when of a case with something after case keyword - registers an offense for literal 1 in post-loop while - registers an offense for literal {} in complex ! - accepts `false` literal in post-loop `until` - registers an offense for literal :"#{a}" in until - registers an offense for literal [1] in case - accepts dstr literal in case - registers an offense for literal 1 in complex cond - registers an offense for literal :sym in complex cond - registers an offense for literal 2.0 in until - registers an offense for literal 2.0 in ! - accepts literal :"#{a}" in non-toplevel and/or - registers an offense for literal :"#{a}" in a when of a case without anything after case keyword - accepts literal 2.0 if it's not an and/or operand - registers an offense for literal [1] in ! - accepts literal :sym in a when of a case with something after case keyword - registers an offense for literal {} in while - registers an offense for literal 2.0 in while - accepts literal 1 if it's not an and/or operand - registers an offense for literal 1 in ! - accepts literal [1] in a when of a case with something after case keyword - registers an offense for literal :"#{a}" in ! - registers an offense for literal 2.0 in a when of a case without anything after case keyword - registers an offense for literal 1 in a when of a case without anything after case keyword - registers an offense for `!:sym` - registers an offense for literal {} in post-loop while - registers an offense for literal 2.0 in post-loop while - accepts literal :sym in non-toplevel and/or - registers an offense for literal 2.0 in if - accepts literal 2.0 in non-toplevel and/or - accepts literal :sym if it's not an and/or operand - registers an offense for literal 2.0 in post-loop until - accepts literal 2.0 in a when of a case with something after case keyword - registers an offense for literal [1] in while - registers an offense for literal :sym in case - accepts literal 1 in non-toplevel and/or - registers an offense for literal 2.0 in complex ! - registers an offense for `not {}` - registers an offense for literal :"#{a}" in if - accepts `false` literal in `until` - registers an offense for `![1]` - registers an offense for literal :"#{a}" in post-loop until - accepts literal :"#{a}" in a when of a case with something after case keyword - registers an offense for `!2.0` - registers an offense for literal [1] in a when of a case without anything after case keyword - registers an offense for literal :sym in while - >= Ruby 2.7 - registers an offense for literal 1 in case match without a match var - accepts literal 1 in a when of a case match - accepts an offense for literal 1 in case match with a match var - >= Ruby 2.7 - accepts an offense for case match with a match var - accepts array literal in case match, if it has non-literal elements - registers an offense for case match with a primitive array condition - accepts array literal in case match, if it has nested non-literal element - accepts dstr literal in case match - >= Ruby 2.7 - registers an offense for literal :sym in case match without a match var - accepts literal :sym in a when of a case match - accepts an offense for literal :sym in case match with a match var - >= Ruby 2.7 - accepts literal 2.0 in a when of a case match - registers an offense for literal 2.0 in case match without a match var - accepts an offense for literal 2.0 in case match with a match var - >= Ruby 2.7 - accepts literal :"#{a}" in a when of a case match - registers an offense for literal :"#{a}" in case match without a match var - accepts an offense for literal :"#{a}" in case match with a match var - >= Ruby 2.7 - accepts literal {} in a when of a case match - accepts an offense for literal {} in case match with a match var - registers an offense for literal {} in case match without a match var - >= Ruby 2.7 - accepts an offense for literal [1] in case match with a match var - registers an offense for literal [1] in case match without a match var - accepts literal [1] in a when of a case match +RuboCop::Cop::Naming::BlockParameterName + registers offense when param contains uppercase characters + registers offense when param ends in number + does not register for block without parameters + registers offense when param is less than minimum length + registers offense when param with prefix is less than minimum length + does not register for brace block without parameters + can register multiple offenses in one block + does not register offense for valid parameter names + with AllowedNames + registers unlisted offensive names + accepts specified block param names + with AllowNamesEndingInNumbers + accept params that end in numbers + with ForbiddenNames + registers offense for param listed as forbidden + accepts param that uses a forbidden name's letters -RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters - accepts other percent literals - accepts execute-string literals - for I type and ["{", "}"] delimiters - registers an offense for literals with escaped and other spaces - accepts spaces between entries - accepts literals with escaped spaces - registers an offense for spaces before final delimiter - registers an offense for unnecessary spaces - accepts multi-line literals - accepts literals without additional spaces - accepts newlines and additional following alignment spaces - registers an offense for spaces after first delimiter - accepts multi-line literals within a method - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for i type and ["{", "}"] delimiters - registers an offense for spaces before final delimiter - accepts spaces between entries - registers an offense for spaces after first delimiter - registers an offense for literals with escaped and other spaces - registers an offense for unnecessary spaces - accepts multi-line literals within a method - accepts literals without additional spaces - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - accepts multi-line literals - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for i type and ["(", ")"] delimiters - accepts multi-line literals within a method - registers an offense for unnecessary spaces - accepts multi-line literals - accepts newlines and additional following alignment spaces - registers an offense for spaces before final delimiter - accepts literals without additional spaces - registers an offense for spaces after first delimiter - accepts spaces between entries - registers an offense for literals with escaped and other spaces - accepts literals with escaped spaces - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - for i type and ["[", "]"] delimiters - accepts spaces between entries - accepts literals without additional spaces - registers an offense for literals with escaped and other spaces - accepts multi-line literals within a method - accepts multi-line literals - registers an offense for unnecessary spaces - registers an offense for spaces after first delimiter - registers an offense for spaces before final delimiter - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - for x type and ["[", "]"] delimiters - registers an offense for spaces before final delimiter - registers an offense for literals with escaped and other spaces - accepts literals without additional spaces - registers an offense for unnecessary spaces - accepts spaces between entries - accepts multi-line literals within a method - accepts literals with escaped spaces - accepts multi-line literals - accepts newlines and additional following alignment spaces - registers an offense for spaces after first delimiter - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for W type and ["(", ")"] delimiters - accepts literals with escaped spaces - registers an offense for spaces before final delimiter - accepts newlines and additional following alignment spaces - registers an offense for spaces after first delimiter - accepts multi-line literals - registers an offense for unnecessary spaces - accepts multi-line literals within a method - accepts literals without additional spaces - registers an offense for literals with escaped and other spaces - accepts spaces between entries - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - for W type and ["{", "}"] delimiters - registers an offense for spaces after first delimiter - registers an offense for spaces before final delimiter - accepts newlines and additional following alignment spaces - accepts literals without additional spaces - accepts multi-line literals within a method - accepts multi-line literals - registers an offense for unnecessary spaces - registers an offense for literals with escaped and other spaces - accepts spaces between entries - accepts literals with escaped spaces - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for x type and ["!", "!"] delimiters - registers an offense for spaces before final delimiter - accepts multi-line literals - accepts literals with escaped spaces - registers an offense for unnecessary spaces - registers an offense for literals with escaped and other spaces - accepts spaces between entries - registers an offense for spaces after first delimiter - accepts newlines and additional following alignment spaces - accepts multi-line literals within a method - accepts literals without additional spaces - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - for x type and ["{", "}"] delimiters - accepts literals with escaped spaces - registers an offense for spaces before final delimiter - accepts spaces between entries - registers an offense for spaces after first delimiter - accepts multi-line literals within a method - registers an offense for literals with escaped and other spaces - accepts multi-line literals - accepts literals without additional spaces - registers an offense for unnecessary spaces - accepts newlines and additional following alignment spaces - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for W type and ["!", "!"] delimiters - accepts literals with escaped spaces - registers an offense for spaces before final delimiter - accepts literals without additional spaces - accepts spaces between entries - accepts multi-line literals within a method - accepts newlines and additional following alignment spaces - accepts multi-line literals - registers an offense for literals with escaped and other spaces - registers an offense for spaces after first delimiter - registers an offense for unnecessary spaces - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - for W type and ["[", "]"] delimiters - accepts literals with escaped spaces - accepts spaces between entries - accepts literals without additional spaces - registers an offense for literals with escaped and other spaces - accepts multi-line literals - registers an offense for unnecessary spaces - accepts multi-line literals within a method - accepts newlines and additional following alignment spaces - registers an offense for spaces after first delimiter - registers an offense for spaces before final delimiter - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - for w type and ["{", "}"] delimiters - accepts literals without additional spaces - registers an offense for spaces before final delimiter - accepts literals with escaped spaces - accepts spaces between entries - accepts multi-line literals - registers an offense for literals with escaped and other spaces - accepts newlines and additional following alignment spaces - accepts multi-line literals within a method - registers an offense for unnecessary spaces - registers an offense for spaces after first delimiter - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for x type and ["(", ")"] delimiters - accepts spaces between entries - accepts newlines and additional following alignment spaces - registers an offense for unnecessary spaces - accepts literals with escaped spaces - accepts literals without additional spaces - registers an offense for spaces before final delimiter - accepts multi-line literals - accepts multi-line literals within a method - registers an offense for spaces after first delimiter - registers an offense for literals with escaped and other spaces - with space in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - for w type and ["(", ")"] delimiters - accepts newlines and additional following alignment spaces - accepts literals without additional spaces - accepts multi-line literals - accepts literals with escaped spaces - registers an offense for literals with escaped and other spaces - accepts spaces between entries - registers an offense for spaces after first delimiter - registers an offense for spaces before final delimiter - registers an offense for unnecessary spaces - accepts multi-line literals within a method - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - for w type and ["!", "!"] delimiters - accepts newlines and additional following alignment spaces - registers an offense for spaces before final delimiter - registers an offense for unnecessary spaces - accepts multi-line literals - accepts literals with escaped spaces - accepts spaces between entries - registers an offense for spaces after first delimiter - accepts multi-line literals within a method - registers an offense for literals with escaped and other spaces - accepts literals without additional spaces - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for I type and ["[", "]"] delimiters - accepts multi-line literals within a method - accepts multi-line literals - registers an offense for spaces before final delimiter - registers an offense for spaces after first delimiter - accepts literals with escaped spaces - accepts spaces between entries - accepts literals without additional spaces - registers an offense for literals with escaped and other spaces - registers an offense for unnecessary spaces - accepts newlines and additional following alignment spaces - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - for I type and ["!", "!"] delimiters - registers an offense for literals with escaped and other spaces - accepts literals with escaped spaces - accepts spaces between entries - registers an offense for unnecessary spaces - accepts multi-line literals - accepts newlines and additional following alignment spaces - registers an offense for spaces after first delimiter - accepts literals without additional spaces - registers an offense for spaces before final delimiter - accepts multi-line literals within a method - with newline in blank percent literals - registers and corrects an offense - with spaces in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for I type and ["(", ")"] delimiters - accepts newlines and additional following alignment spaces - accepts spaces between entries - registers an offense for literals with escaped and other spaces - accepts multi-line literals - registers an offense for spaces after first delimiter - registers an offense for spaces before final delimiter - accepts multi-line literals within a method - accepts literals without additional spaces - accepts literals with escaped spaces - registers an offense for unnecessary spaces - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for i type and ["!", "!"] delimiters - registers an offense for spaces after first delimiter - accepts literals without additional spaces - accepts spaces between entries - accepts literals with escaped spaces - registers an offense for unnecessary spaces - accepts multi-line literals within a method - registers an offense for spaces before final delimiter - registers an offense for literals with escaped and other spaces - accepts multi-line literals - accepts newlines and additional following alignment spaces - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense - for w type and ["[", "]"] delimiters - registers an offense for unnecessary spaces - accepts spaces between entries - accepts multi-line literals - accepts literals with escaped spaces - accepts multi-line literals within a method - registers an offense for spaces after first delimiter - registers an offense for literals with escaped and other spaces - accepts newlines and additional following alignment spaces - registers an offense for spaces before final delimiter - accepts literals without additional spaces - with spaces in blank percent literals - registers and corrects an offense - with newline in blank percent literals - registers and corrects an offense - with space in blank percent literals - registers and corrects an offense +RuboCop::Cop::Style::TrailingCommaInHashLiteral + with single line list of values + when EnforcedStyleForMultiline is no_comma + registers an offense for trailing comma in a literal + accepts empty literal + accepts single element literal without trailing comma + accepts literal without trailing comma + when EnforcedStyleForMultiline is comma + accepts empty literal + accepts literal without trailing comma + registers an offense for trailing comma in a literal + accepts single element literal without trailing comma + when EnforcedStyleForMultiline is consistent_comma + accepts literal without trailing comma + accepts single element literal without trailing comma + accepts empty literal + registers an offense for trailing comma in a literal + with multi-line list of values + when EnforcedStyleForMultiline is no_comma + accepts comma in comment after last value item + accepts comma inside a heredoc parameters at the end + registers an offense for trailing comma in literal + accepts literal with no trailing comma + when EnforcedStyleForMultiline is comma + accepts trailing comma + accepts trailing comma after a heredoc + registers an offense for trailing comma in a comment + accepts a multiline hash with a single pair and trailing comma + registers an offense for no trailing comma + when closing bracket is on same line as last value + accepts literal with no trailing comma + when EnforcedStyleForMultiline is consistent_comma + accepts a multiline hash with pairs on a single line andtrailing comma + registers an offense for no trailing comma + accepts a multiline hash with a single pair and trailing comma + accepts trailing comma after a heredoc + accepts trailing comma + when closing bracket is on same line as last value + registers an offense for literal with no trailing comma -RuboCop::Cop::InternalAffairs::RedundantMessageArgument - does not register an offense when `#message` with another node is passed - does not register an offense when formatted `MSG` is passed - when `#message` with offending node is passed - when there are others keyword arguments - registers an offense - when message is the only keyword argument - registers an offense - when `#message` is passed +RuboCop::Cop::Style::MultilineIfModifier + if guard clause + allows a one liner + allows a multiline condition registers an offense - when `MSG` is passed + registers an offense when indented + unless guard clause registers an offense + registers an offense when indented + allows a multiline condition + allows a one liner -RuboCop::Cop::Bundler::DuplicatedGem - when investigating Ruby files - does not register any offenses - when investigating Gemfiles - does not register an offense when gem is duplicated within `if-else` statement - does not register an offense when gem is duplicated within `if-elsif` statement - does not register an offense when gem is duplicated within `case` statement - registers an offense when gem from default group is conditionally duplicated - and a duplicated gem is in a git/path/group/platforms block - registers an offense - and a gem is duplicated in default group +RuboCop::Cop::InternalAffairs::RedundantLocationArgument + when location argument is not passed + does not register an offense + when location argument is passed + when location argument is :expression registers an offense - and the file is empty - does not register any offenses - and no duplicate gems are present - does not register any offenses + removes default `location` surrounded by other keywords + removes default `location` when preceded by another keyword + when there is a message argument + registers an offense + when location argument does not equal to :expression + does not register an offense -RuboCop::Formatter::QuietFormatter - #report_file - the file is outside of the current working directory - prints as absolute path - when the offense is correctable - prints message as-is - when the offense is not corrected - prints message as-is - the file is under the current working directory - prints as relative path - when the offense is automatically corrected - prints [Corrected] along with message - #report_summary - when a offense detected - handles pluralization correctly - when an offense is corrected - prints about correction - when a offense detected and a offense correctable +RuboCop::Cop::Style::IfUnlessModifierOfIfUnless + provides a good error message + nested conditionals + accepts + ternary with modifier + registers an offense and corrects + conditional with modifier in body + accepts + conditional with modifier + registers an offense and corrects + `unless` / `else` with modifier + registers an offense and corrects + +RuboCop::Cop::Lint::UselessRuby2Keywords + when `ruby2_keywords` is given a `def` node + does not register an offense for a method with a `restarg` and no `kwrestarg` + registers an offense for a method with only `kwrestarg` + registers an offense for a method with a `restarg` and keyword args + registers an offense for a method with a `restarg` and `kwrestarg` + does not register an offense for a method with a `restarg` other optional args + does not register an offense for a method with a `restarg` and `blockarg` + registers an offense for a method with only keyword args + registers an offense for a method with only positional args + registers an offense for a method with a `restarg` and `kwoptarg` + registers an offense for a method without arguments + does not register an offense for a method with a `restarg` other positional args + with a dynamically defined method + registers an offense for a numblock + does not register an offense when the method has a `restarg` and a `shadowarg` + registers an offense for an unnecessary `ruby2_keywords` + does not register an offense for an allowed `ruby2_keywords` + registers an offense when the method has a `shadowarg` + when `ruby2_keywords` is given a symbol + does not register an offense when there is no `def` + does not register an offense for an allowed def + registers an offense for an unnecessary `ruby2_keywords` + does not register an offense when the `def` is at a different depth + +RuboCop::Formatter::QuietFormatter + #report_file + when the offense is correctable + prints message as-is + the file is outside of the current working directory + prints as absolute path + the file is under the current working directory + prints as relative path + when the offense is not corrected + prints message as-is + when the offense is automatically corrected + prints [Corrected] along with message + #report_summary + when no files inspected handles pluralization correctly - when 2 offenses are corrected + when a offense detected and a offense correctable handles pluralization correctly - when no files inspected + when 2 offenses are corrected and 2 offenses correctable handles pluralization correctly when 2 offenses detected and 2 offenses correctable handles pluralization correctly - when 2 offenses detected + when a offense detected handles pluralization correctly - when 2 offenses are corrected and 2 offenses correctable + when 2 offenses are corrected handles pluralization correctly when a file inspected and no offenses detected handles pluralization correctly + when 2 offenses detected + handles pluralization correctly + when an offense is corrected + prints about correction -RuboCop::Cop::Style::ReturnNil - when enforced style is `return_nil` - registers an offense for return - does not register an offense for returning others - when enforced style is `return` - does not register an offense for returning others - does not register an offense for return nil from iterators - registers an offense for return nil +RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands + registers an offense for `>=` with duplicate operands + registers an offense for `<=` with duplicate operands + registers an offense for `||` with duplicate operands + does not crash on operator without any argument + does not register an offense for `*` with duplicate operands + registers an offense for `^` with duplicate operands + does not register an offense for `<<` with duplicate operands + registers an offense for `|` with duplicate operands + registers an offense for `>` with duplicate operands + does not register an offense for `+` with duplicate operands + does not register an offense for `>>` with duplicate operands + registers an offense for `/` with duplicate operands + does not register an offense for `**` with duplicate operands + does not register an offense when using arithmetic operator with numerics + registers an offense for `!=` with duplicate operands + registers an offense for `<=>` with duplicate operands + registers an offense for `===` with duplicate operands + does not register an offense when using binary operator with different operands + registers an offense for `=~` with duplicate operands + registers an offense for `==` with duplicate operands + registers an offense for `&&` with duplicate operands + registers an offense for `-` with duplicate operands + registers an offense for `<` with duplicate operands + registers an offense for `%` with duplicate operands -RuboCop::Cop::Style::StringLiterals - configured with single quotes preferred - does not register an offense for words with non-ascii chars and other control sequences - registers an offense for "\" - accepts double quotes when control characters are used - accepts heredocs - accepts double quotes with some other special symbols - accepts single quotes - can handle a built-in constant parsed as string - accepts double quotes when interpolating & quotes in multiple lines - registers offense for correct + opposite - registers offense for double quotes when single quotes suffice - accepts " in a %w - accepts single quotes in interpolation - detects unneeded double quotes within concatenated string - accepts double quotes when interpolating a global variable - accepts double quotes when unicode control sequence is used - accepts double quotes when interpolating an instance variable - accepts double quotes at the start of regexp literals - can handle character literals - registers an offense for "\"" - accepts double quotes in interpolation - accepts double quotes when single quotes are used - accepts \\\n in a string - accepts % quotes - accepts double quotes when interpolating a class variable - accepts double quotes when new line is used - accepts %q and %Q quotes - registers an offense for words with non-ascii chars - when configured with a bad value - fails - when ConsistentQuotesInMultiline is true - and EnforcedStyle is double_quotes - registers an offense for unneeded single quotes in continuation - accepts continued strings using all double quotes - doesn't register offense for single quotes with embedded double - registers an offense for mixed quote styles in a continued string - and EnforcedStyle is single_quotes - accepts for double quotes with an escaped special character - accepts for double quotes with an escaped normal character - registers an offense for mixed quote styles in a continued string - doesn't register offense for double quotes with interpolation - doesn't register offense for double quotes with embedded single - doesn't choke on heredocs with inconsistent indentation - registers an offense for unneeded double quotes in continuation - registers an offense for strings with line breaks in them - accepts continued strings using all single quotes - configured with double quotes preferred - accepts escaped single quote in string with escaped non-' character - accepts single quoted string with backslash - accepts single quotes in string with escaped non-' character - registers offense for single quotes when double quotes would be equivalent - registers offense for opposite + correct - accepts %q and %Q quotes - flags single quotes with plain # (not #@var or #{interpolation} or #$global - accepts % quotes - accepts heredocs - accepts single quotes at the start of regexp literals - can handle a built-in constant parsed as string - accepts single quotes in interpolation - does not accept multiple escaped single quotes in single quotes - accepts single quotes when they are needed - accepts ' in a %w - registers offense for escaped single quote in single quotes - accepts double quotes +RuboCop::Cop::InternalAffairs::EmptyLineBetweenExpectOffenseAndCorrection + does not register an offense when using empty line between `expect_offense` and `expect_no_corrections` + does not register an offense when using only `expect_offense` + registers and corrects an offense when using no empty line between `expect_offense` and `expect_correction`with variable argument + does not register an offense when using empty line between `expect_offense` and `expect_correction` with heredoc argument + does not register an offense when using empty line between `expect_offense` and `expect_correction`with variable argument + registers and corrects an offense when using no empty line between `expect_offense` and `expect_no_corrections` + registers and corrects an offense when using no empty line between `expect_offense` and `expect_correction` with heredoc argument -RuboCop::Cop::Layout::SpaceAfterSemicolon - registers an offense and corrects semicolon without space after it - does not crash if semicolon is the last character of the file - inside block braces - when EnforcedStyle for SpaceInsideBlockBraces is no_space - accepts no space between a semicolon and a closing brace - behaves like common behavior - accepts a space between a semicolon and a closing brace - when EnforcedStyle for SpaceInsideBlockBraces is space - registers an offense and corrects no space between a semicolon and a closing brace - behaves like common behavior - accepts a space between a semicolon and a closing brace +RuboCop::YAMLDuplicationChecker + when yaml has duplicated keys in the top level + calls block + calls block with keys + when yaml has duplicated keys in the second level + calls block with keys + calls block + when yaml does not have any duplication + does not call block -RuboCop::ConfigStore - .for - always uses config specified in command line - when no config specified in command line - searches for config path if not available in cache - gets config path and config from cache if available - when --force-default-config option is specified - uses default config without searching for config path +RuboCop::Cop::Style::RedundantSortBy + autocorrects array.sort_by { |y| y } + autocorrects array.sort_by { |x| x } + autocorrects array.sort_by do |x| x end + Ruby 2.7 + autocorrects array.sort_by { |x| x } -RuboCop::Cop::Layout::MultilineArrayLineBreaks - when two elements on same line - registers an offense and corrects - when on same line - does not add any offenses - when nested arrays - registers an offense and corrects - when on same line, separate line from brackets - does not add any offenses +RuboCop::Cop::Style::FileRead + registers an offense for and corrects the `File.open` with inline read block (mode 'rb') + registers an offense for and corrects the `File.open` with inline read block (mode 'r') + registers an offense for and corrects the `File.open` with multiline read block (mode 'r') + registers an offense for and corrects `File.open(filename, 'rt').read` + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+b') + registers an offense for and corrects the `File.open` with inline read block (mode 'r+b') + registers an offense for and corrects `File.open(filename, 'rb').read` + registers an offense for and corrects the `File.open` with multiline read block (mode 'rb') + registers an offense for and corrects the `File.open` with multiline read block (implicit text mode) + does not register an offense when not reading from the block variable + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r') + registers an offense for and corrects the `File.open` with multiline read block (mode 'rt') + registers an offense for and corrects the `File.open` with inline read block (mode 'rt') + registers an offense for and corrects `File.open(filename).read` + registers an offense for and corrects the `File.open` with inline read block (mode 'r+') + registers an offense for and corrects `File.open(filename, 'r+t').read` + registers an offense for and corrects `File.open(filename, 'r').read` + registers an offense for and corrects the `File.open` with inline read block (implicit text mode) + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+t') + registers an offense for and corrects the `File.open` with multiline read block (mode 'r+') + registers an offense for and corrects the `File.open` with inline read block (mode 'r+t') + registers an offense for and corrects the `File.open` with symbolic read proc (implicit text mode) + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'rt') + registers an offense for and corrects the `File.open` with multiline read block (mode 'r+t') + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+') + registers an offense for and corrects `File.open(filename, 'r+').read` + registers an offense for and corrects the `File.open` with symbolic read proc (mode 'rb') + registers an offense for and corrects `::File.open(filename).read` + registers an offense for and corrects `File.open(filename, 'r+b').read` + registers an offense for and corrects the `File.open` with multiline read block (mode 'r+b') -RuboCop::Cop::Style::DateTime - registers an offense when using ::DateTime for current time - registers an offense when using DateTime for modern date - does not register an offense when using ::DateTime for historic date - registers an offense when using DateTime for current time - does not register an offense when using DateTime for historic date - does not register an offense when using Date for modern date - does not register an offense when using Time for current time - does not register an offense when using DateTime in another namespace - when configured to not allow #to_datetime - registers an offense - when configured to allow #to_datetime - does not register an offense +RuboCop::Cop::Lint::SafeNavigationConsistency + registers a single offense and corrects when safe navigation is used multiple times + registers an offense and corrects using safe navigation on the left of && + registers and corrects multiple offenses + registers an offense and corrects using safe navigation on the left of || + allows && without safe navigation + registers an offense and corrects using unsafe navigation with both && and || + registers an offense and corrects using unsafe navigation and the safe navigation appears in a group + registers an offense and corrects using safe navigation inside of separated conditions + registers an offense and corrects unsafe navigation that appears before safe navigation + registers an offense and corrects using safe navigation in conditions on the right hand side + registers an offense and corrects using safe navigation on the right of || + registers an offense and corrects assignment + allows calls to methods that nil responds to + registers an offense but does not correct non dot method calls + registers an offense and corrects using safe navigation on the right of && + allows safe navigation when different variables are used + allows || without safe navigation + registers an offense and corrects when there is code before or after the condition + registers an offense and corrects using unsafe navigation with grouped conditions -RuboCop::Cop::Badge - compares by value - exposes department name - exposes cop name - can be converted to a string with the Department/CopName format - #camel_case - converts "lint" to CamelCase - converts "foo_bar" to CamelCase - converts "rspec" to CamelCase - #qualified? - says `CopName` is not qualified - says `Department/CopName` is qualified - says `Deep/Department/CopName` is qualified +RuboCop::Cop::VariableForce::Scope + #name + when the scope is instance method definition + returns the method name + when the scope is singleton method definition + returns the method name + #each_node + inner scope boundary handling + when there's a method invocation with block + yields only the block node and the child send node + when there's a singleton method definition + yields only the defs node and the method host node + outer scope boundary handling + when the scope is instance method + yields the argument and the body nodes + when the scope is class + yields the body nodes + when the scope is singleton method + yields the argument and the body nodes + when the scope is module + yields the body nodes + when the scope is top level + yields the body nodes + when the scope is singleton class + yields the body nodes + when the scope is block + yields the argument and the body nodes + #include? + with child node the scope does not include + is expected to equal false + with ancestor node the scope does not include + is expected to equal false + with node of the scope itself + is expected to equal false + with child node the scope includes + is expected to equal true + with descendant node the scope does not include + is expected to equal false .new - assigns name - assigns name - assigns department - assigns name - assigns name - assigns department - assigns department - assigns department - .for - parses cop class name - parses cop class name - parses cop class name - parses cop class name - parses cop class name - .parse - parses identifier - parses identifier - parses identifier - parses identifier - parses identifier - parses identifier - -RuboCop::RakeTask - defining tasks - creates a rubocop task and a rubocop auto_correct task - creates a rubocop task and a rubocop autocorrect task - creates a named task and a named autocorrect task - creates a named task and a named auto_correct task - running tasks - will not error when result is not 0 and fail_on_error is false - runs with specified options if a block is given - allows nested arrays inside formatters, options, and requires - uses the default formatter from .rubocop.yml if no formatter option is given - exits when result is not 0 and fail_on_error is true - runs with default options - autocorrect - runs with --autocorrect-all - runs with --autocorrect - runs with with the options that were passed to its parent task - -RuboCop::Cop::MessageAnnotator - #urls - returns multiple reference urls - returns an empty array without StyleGuide URL - returns reference url when it is specified - returns style guide url when it is specified - returns style guide and reference url when they are specified - returns an empty array if the reference url is blank - #annotate - with default options - returns the message - when the output format is JSON - returns the message unannotated - with options on - returns an annotated message - with style guide url - when StyleGuide is set in the config - adds style guide url - when StyleGuide is not set in the config - does not add style guide url - when a base URL is specified - can accept relative paths if base has a full path - can use a path-based setting - combines correctly with a target-based setting - does not specify a URL if a cop does not have one - allows absolute URLs in the cop config - when a department other than AllCops is specified - returns style guide url when it is specified - when a nested department is specified - returns style guide url when it is specified - -RuboCop::Cop::Metrics::ClassLength - accepts a class with 5 lines - accepts a class with less than 5 lines - rejects a class with more than 5 lines - accepts empty classes - reports the correct beginning and end lines - does not count blank lines - when inspecting a class defined with Class.new - registers an offense - when a class has inner classes - rejects a class with 6 lines that belong to the class directly - does not count lines of inner classes - when CountComments is disabled - accepts classes that only contain comments - when inspecting a class defined with ::Class.new - registers an offense - when overlapping constant assignments - does not register an offense - when `CountAsOne` is not empty - folds array into one line - when CountComments is enabled - also counts commented lines - registers an offense for a class that only contains comments - when inspecting a class defined with Struct.new - registers an offense - registers an offense when inspecting or equals (`||=`) for constant - registers an offense when multiple assignments to constants - when using numbered parameter - when inspecting a class defined with ::Class.new - registers an offense - when inspecting a class defined with Struct.new - registers an offense when multiple assignments to constants - registers an offense - registers an offense when inspecting or equals (`||=`) for constant - when inspecting a class defined with Class.new - registers an offense + when begin node is passed + accepts that as top level scope + when lvasgn node is passed + accepts that as top level scope + #body_node + when the scope is top level + returns the body node + when the scope is singleton method + returns the body node + when the scope is singleton class + returns the body node + when the scope is module + returns the body node + when the scope is instance method + returns the body node + when the scope is block + returns the body node + when the scope is class + returns the body node -RuboCop::RemoteConfig - .inherit_from_remote - when the remote includes file starting with `./` - returns remote includes URI - .file - downloads the file if cache lifetime has been reached - downloads the file if the file does not exist - does not download the file if cache lifetime has not been reached - when remote URL is configured with basic auth - does not download the file if cache lifetime has not been reached - downloads the file if the file does not exist - downloads the file if cache lifetime has been reached - when the remote URL responds with 404 - raises error - when the remote URL responds with 500 - raises error - when the remote URL responds with 500 - raises error - when remote URL is configured with token auth - downloads the file if cache lifetime has been reached - does not download the file if cache lifetime has not been reached - downloads the file if the file does not exist - when the remote URL responds with 404 - raises error - when the network is inaccessible - reuses the existing cached file - when the remote URL responds with redirect - follows the redirect and downloads the file - when the remote URL responds with not modified - reuses the existing cached file +RuboCop::Cop::Style::InfiniteLoop + accepts while true if loop {} would change semantics + registers an offense for while true if loop {} would work because it is an instance variable being assigned + registers an offense for a while loop with [1] as condition + registers an offense for a until loop with nil as condition + registers an offense for a while loop with 2.0 as condition + registers an offense for a while loop with 1 as condition + registers an offense for modifier until false if loop {} would not change semantics + registers an offense for until false if loop {} would work because the assigned variable is not used afterwards + registers an offense for while true or until false if loop {} would work because of an earlier assignment + accepts modifier while true if loop {} would change semantics + registers an offense for until false if loop {} would work because of previous assignment in a while loop + accepts Kernel#loop + registers an offense for a until loop with false as condition + registers an offense for a while loop with {} as condition + behaves like autocorrector + autocorrects the usage of until with do + autocorrects begin-end-until with two statements + autocorrects the usage of until without do + autocorrects begin-end-until with one statement + autocorrects single line modifier until with and + autocorrects single line modifier until + with non-default indentation width + autocorrects multi-line modifier until and indents correctly + behaves like autocorrector + autocorrects the usage of while with do + autocorrects single line modifier while + autocorrects begin-end-while with one statement + autocorrects the usage of while without do + autocorrects single line modifier while with and + autocorrects begin-end-while with two statements + with non-default indentation width + autocorrects multi-line modifier while and indents correctly -RuboCop::Cop::Layout::HashAlignment - accepts single line hash - accepts pairs that don't start a line - accepts several pairs per line - register no offense for yield without args - register no offense for superclass call without args - with `EnforcedHashRocketStyle`: `table` - and a double splat argument after a hash key - registers an offense on the misaligned key and corrects - and aligned keys but a double splat argument after - does not register an offense on the `kwsplat` - and a misaligned double splat argument +RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective + registers an offense for enabled cop within source code + registers an offense for disabled cop within source code + registers an offense for disabling all cops + with AllowedCops + when an non-allowed cop is disabled registers an offense and corrects - and misaligned keys + when an mix of cops are disabled registers an offense and corrects - when the only item is a kwsplat + when using leading source comment does not register an offense - with default configuration - does not register an offense when value starts on next line - registers an offense and corrects mixed hash styles - registers an offense and corrects table alignment - registers an offense and corrects zero or multiple spaces - registers an offense and corrects alignment when using double splat in an explicit hash - registers an offense and corrects misaligned mixed multiline hash keys - registers an offense and corrects separator alignment - registers an offense and corrects alignment when using double splat in braces - registers an offense and corrects misaligned hash keys - accepts left-aligned hash keys with single spaces - registers an offense and corrects multiline value starts in wrong place - with implicit hash as last argument - registers an offense and corrects right alignment of keys - accepts an empty hash - accepts aligned hash keys - registers an offense and corrects misaligned hash keys - with `EnforcedColonStyle`: `table` - and a double splat argument after a hash key - registers an offense on the misaligned key and corrects - when using hash value omission - and aligned keys - does not register an offense and corrects - and misaligned keys - registers an offense and corrects - and aligned keys but a double splat argument after - does not register an offense on the `kwsplat` - when the only item is a kwsplat + when an allowed cop is disabled does not register an offense - and a misaligned double splat argument - registers an offense and corrects - ignore explicit last argument hash - registers an offense and corrects misaligned keys in implicit hash - accepts misaligned keys in explicit hash - accepts misaligned keys in explicit hash for yield - registers an offense and corrects misaligned keys in implicit hash for super - accepts misaligned keys in explicit hash for super - registers an offense and corrects misaligned keys in implicit hash for yield - when using hash value omission - accepts misaligned keys in explicit hash - registers an offense and corrects misaligned keys in implicit hash - always inspect last argument hash - registers an offense and corrects misaligned keys in explicit hash for yield - registers an offense and corrects misaligned keys in implicit hash for super - registers an offense and corrects misaligned keys in implicit hash for yield - registers offense and corrects misaligned keys in explicit hash - registers offense and corrects misaligned keys in implicit hash - registers an offense and corrects misaligned keys in explicit hash for super - when using hash value omission - registers offense and corrects misaligned keys in explicit hash - registers offense and corrects misaligned keys in implicit hash - when `EnforcedStyle: with_fixed_indentation` of `ArgumentAlignment` - registers and corrects an offense when using misaligned keyword arguments - does not register an offense for an empty hash literal - does not register an offense using aligned hash literal - register and corrects an offense - does not register an offense using aligned hash argument for `proc.()` - when using hash value omission - does not register and corrects an offense when using aligned keyword arguments - register and corrects an offense - with table+separator alignment configuration - accepts a single method argument entry with colon - with multiple preferred(key and table) alignment configuration - registers an offense and corrects misaligned hash values - registers an offense and corrects misaligned hash values, works separate for each hash - registers an offense and corrects misaligned hash values, prefer key when least offenses - accepts aligned hash keys, by table - accepts aligned hash keys, by both - registers an offense and corrects misaligned hash values, prefer table when least offenses - accepts aligned hash keys with mixed hash style - registers an offense and corrects misaligned hash keys with mixed hash style - accepts an empty hash - accepts aligned hash keys, by keys - table and key config - registers an offense and corrects misaligned hash values, prefer table because it is specified first - with table alignment configuration - accepts several pairs per line - accepts hashes that use different separators - accepts an empty hash - registers an offense and corrects for misaligned hash keys - registers an offense for misaligned hash values - accepts hashes that use different separators and double splats - accepts a multiline array of single line hashes - registers an offense and corrects misaligned hash rockets - accepts a symbol only hash followed by a keyword splat - accepts pairs that don't start a line - accepts single line hash - accepts aligned hash keys and values - accepts a keyword splat only hash - when using hash value omission - accepts single line hash - accepts pairs that don't start a line - accepts several pairs per line - when using hash value omission - accepts aligned hash keys and values - with different settings for => and : - registers offenses and correct misaligned entries - accepts aligned entries - always ignore last argument hash - accepts misaligned keys in implicit hash for super - accepts misaligned keys in explicit hash for yield - accepts misaligned keys in implicit hash for yield - accepts misaligned keys in implicit hash - accepts misaligned keys in explicit hash for super - accepts misaligned keys in explicit hash - when using hash value omission - accepts pairs that don't start a line - accepts several pairs per line - accepts single line hash - ignore implicit last argument hash - registers an offense and corrects misaligned keys in explicit hash for yield - accepts misaligned keys in implicit hash for super - registers an offense and corrects misaligned keys in explicit hash - accepts misaligned keys in implicit hash for yield - accepts misaligned keys in implicit hash - registers an offense and corrects misaligned keys in explicit hash for super - with separator alignment configuration - registers an offense and corrects mixed indentation and spacing - accepts several pairs per line - accepts aligned hash keys - accepts hashes with different separators - accepts pairs that don't start a line - accepts single line hash - registers an offense and corrects misaligned hash rockets - accepts an empty hash - registers an offense and corrects misaligned hash values - doesn't break code by moving long keys too far left - when using hash value omission - accepts pairs that don't start a line - accepts several pairs per line - accepts single line hash - when using hash value omission - registers an offense and corrects mixed indentation and spacing - accepts aligned hash keys - with invalid configuration - fails - -RuboCop::Formatter::DisabledConfigFormatter - when exclude_limit option is omitted - disables the cop with 15 offending files - when there's .rubocop.yml - merges in excludes from .rubocop.yml - when no files are inspected - creates a .rubocop_todo.yml even in such case - when any offenses are detected - displays YAML configuration disabling all cops with offenses - with autocorrect supported cop - adds a comment about --autocorrect option - when exclude_limit option is passed - respects the file exclusion list limit - -RuboCop::Cop::Lint::MixedRegexpCaptureTypes - does not register offense to a regexp with named capture only - does not register offense to a regexp with numbered capture only - does not register offense when using a Regexp cannot be processed by regexp_parser gem - registers an offense when both of named and numbered captures are used - does not register offense to a regexp with named capture and non-capturing group - when containing a non-regexp literal - does not register an offense when containing a gvar - does not register an offense when containing a method - does not register an offense when containing a constant - does not register an offense when containing a cvar - does not register an offense when containing a lvar - does not register an offense when containing a ivar - -RuboCop::Cop::Utils::FormatString - finds the correct number of fields - #valid? - returns false when there are unnumbered and numbered formats - returns true when there are only named with escaped `%` formats - returns false when there are numbered and named formats - returns true when there are only unnumbered formats - returns false when there are unnumbered and named formats - returns true when there are only numbered formats - returns true when there are only named formats - #named_interpolation? - behaves like named format sequence - detects named format sequence - does not detect escaped named format sequence - behaves like named format sequence - detects named format sequence - does not detect escaped named format sequence - behaves like named format sequence - detects named format sequence - does not detect escaped named format sequence - behaves like named format sequence - does not detect escaped named format sequence - detects named format sequence - -RuboCop::Cop::Naming::ConstantName - does not check if rhs is another constant - does not check names if rhs is a `Class.new` with conditional assign - does not check names if rhs is a `Struct.new` - allows screaming snake case in const name - allows screaming snake case in multiple const assignment - does not check names if rhs is a method call - registers 1 offense if rhs is offending const assignment - registers an offense for snake case in const name - does not check names if rhs is a `Class.new` - does not check names if rhs is a `Struct.new` with conditional assign - does not check names if rhs is a method call with conditional assign - checks qualified const names - registers an offense for non-POSIX upper case in const name - does not check names if rhs is a method call with block - registers an offense for camel case in const namewhen using frozen object assignment - allows screaming snake case with POSIX upper case characters - registers offenses for camel case in multiple const assignment - does not check if rhs is a non-offensive const assignment - registers an offense for camel case in const namewhen using frozen range assignment - registers an offense for camel case in const name - when a rhs is a conditional expression - when conditional branches contain only constants - does not check names - when conditional branches contain only string values - registers an offense - when conditional branches contain a value other than a constant - does not check names -RuboCop::Cop::Style::PreferredHashMethods - with enforced `short` style - accepts has_value? with no args - accepts has_key? with no args - registers an offense for has_key? with one arg - registers an offense for has_value? with one arg - when using safe navigation operator - registers an offense for has_value? with one arg - with enforced `verbose` style - registers an offense for key? with one arg - registers an offense for value? with one arg - accepts key? with no args - accepts value? with no args +RuboCop::Cop::Style::NegatedIfElseCondition + works with duplicate nodes + does not register an offense when negating condition for `if-elsif` + registers an offense and corrects when negating condition with `!` for `if-else` + correctly moves comments at the end of branches + does not register an offense when only part of the condition is negated + works with comments when one branch is a begin and the other is not + does not register an offense when `if` with negated condition has no `else` branch + works with comments when neither branch is a begin node + moves comments to correct branches during autocorrect + registers an offense and corrects nested `if-else` with negated condition + registers an offense and corrects a multiline ternary + does not register an offense when both branches are empty + works with comments and multiple statements + registers an offense when using negated condition and `if` branch body is empty + registers an offense and corrects when negating condition with `not` for ternary + does not register an offense when `if` with `!!` condition + registers an offense and corrects when negating condition with `not` for `if-else` + does not register an offense when the `else` branch is empty + behaves like negation method + registers an offense and corrects when negating condition with `!=` in begin-end for ternary + registers an offense and corrects when negating condition with `!=` for `if-else` + registers an offense and corrects when negating condition with `!=` in parentheses for `if-else` + registers an offense and corrects when negating condition with `!=` for ternary + registers an offense and corrects when negating condition with `!=` in parentheses for ternary + registers an offense and corrects when negating condition with `!=` in begin-end for `if-else` + behaves like negation method + registers an offense and corrects when negating condition with `!~` in begin-end for ternary + registers an offense and corrects when negating condition with `!~` in parentheses for ternary + registers an offense and corrects when negating condition with `!~` for `if-else` + registers an offense and corrects when negating condition with `!~` in parentheses for `if-else` + registers an offense and corrects when negating condition with `!~` for ternary + registers an offense and corrects when negating condition with `!~` in begin-end for `if-else` -RuboCop::Cop::Gemspec::OrderedDependencies - behaves like ordered dependency - when add_dependency - when gems are not alphabetically sorted +RuboCop::Cop::Style::RescueStandardError + explicit + accepts rescue modifier + when rescuing in a begin block + accepts rescuing StandardError with other errors + accepts rescuing a single error other than StandardErrorassigned to a variable + accepts rescuing StandardError by itself + accepts rescuing a single error other than StandardError + accepts rescuing StandardError with other errors, assigned to a variable + accepts rescuing StandardError by itself, assigned to a variable + when calling rescue without an error class registers an offense - when each individual group of line is sorted - does not register any offenses - When gems are alphabetically sorted - does not register any offenses - when dependency is separated by multiline comment - with TreatCommentsAsGroupSeparators: true - accepts - with TreatCommentsAsGroupSeparators: false + when the error is assigned to a variable registers an offense - behaves like ordered dependency - when add_runtime_dependency - when gems are not alphabetically sorted + when rescuing in a method definition + accepts rescuing StandardError by itself + accepts rescuing StandardError with other errors + accepts rescuing StandardError by itself, assigned to a variable + accepts rescuing StandardError with other errors, assigned to a variable + accepts rescuing a single error other than StandardError + accepts rescuing a single error other than StandardError, assigned to a variable + when rescue is called without an error class registers an offense - when dependency is separated by multiline comment - with TreatCommentsAsGroupSeparators: true - accepts - with TreatCommentsAsGroupSeparators: false - registers an offense - when each individual group of line is sorted - does not register any offenses - When gems are alphabetically sorted - does not register any offenses - When using method call to gem names - does not register any offenses - When using a local variable in an argument of dependent gem - does not register any offenses - when different dependencies are consecutive - does not register any offenses - behaves like ordered dependency - when add_development_dependency - when dependency is separated by multiline comment - with TreatCommentsAsGroupSeparators: true - accepts - with TreatCommentsAsGroupSeparators: false + when the error is assigned to a variable + registers an offense + implicit + accepts rescue modifier + when rescuing in a method definition + accepts rescuing no error class, assigned to a variable + accepts rescuing StandardError with other errors, assigned to a variable + accepts rescuing a single error other than StandardError, assigned to a variable + accepts rescuing StandardError with other errors + accepts rescuing no error class + accepts rescuing a single error other than StandardError + when rescuing StandardError by itself + registers an offense + when the error is assigned to a variable registers an offense - When gems are alphabetically sorted - does not register any offenses - when gems are not alphabetically sorted + when rescuing in a begin block + accepts rescuing a single error class other than StandardError + accepts rescuing a single error class other than StandardError, assigned to a variable + accepts rescuing no error class + accepts rescuing ::StandardError with other errors + accepts rescuing StandardError with other errors, assigned to a variable + accepts rescuing StandardError with other errors + accepts rescuing no error class, assigned to a variable + when rescuing StandardError by itself registers an offense - when each individual group of line is sorted - does not register any offenses - -RuboCop::Cop::Style::InPatternThen - >= Ruby 2.7 - registers an offense for `in b;` - registers an offense for `in b, c, d;` (array pattern) - registers an offense for `in b | c | d;` (alternative pattern) - registers an offense for `in b, c | d;` - accepts `;` separating statements in the body of `in` - when inspecting a case statement with an empty branch - does not register an offense - -RuboCop::Cop::Lint::FloatComparison - registers an offense when comparing with float returning method - does not register an offense when comparing with float method that can return numeric and returns integer - registers an offense when comparing with method on float receiver - registers an offense when comparing with float method that can return numeric and returns float - registers an offense when comparing with arightmetic operator on floats - does not register an offense when comparing with float using epsilon - registers an offense when comparing with float + with ::StandardError + registers an offense + when the error is assigned to a variable + registers an offense + with ::StandardError + registers an offense -RuboCop::Cop::Lint::BooleanSymbol - does not register an offense when using `false` - does not register an offense when using `true` - registers an offense when using `:false` - registers an offense when using `:true` - does not register an offense when using regular symbol - does not register an offense when used inside percent-literal symbol array - when using the new hash syntax - registers an offense when using `key: :false` - registers an offense when using `true:` - registers an offense when using `false:` +RuboCop::Cop::Lint::RaiseException + registers an offense and corrects for `raise` with `Exception.new` and message + registers an offense and corrects for `raise` with `Exception.new(args*)` + registers an offense and corrects for `raise` with `::Exception` and message + registers an offense and corrects for `fail` with `Exception` + registers an offense and corrects for `fail` with `Exception` and message + registers an offense and corrects for `raise` with `::Exception.new` + does not register an offense for `fail` without arguments + registers an offense and corrects for `fail` with `Exception.new` and message + registers an offense and corrects for `raise` with `Exception` + does not register an offense for `raise` without arguments + registers an offense and corrects for `raise` with `Exception` and message + registers an offense and corrects for `raise` with `::Exception` + does not register an offense when raising Exception with explicit namespace + when under namespace + registers an offense and corrects when Exception with cbase specified + does not register an offense when Exception without cbase specified -RuboCop::Cop::Lint::DeprecatedConstants - registers and corrects an offense when using `::Triple::Nested::Constant` - does not register an offense when not using deprecated constant - registers and corrects an offense when using deprecated methods that have no deprecated version - registers and corrects an offense when using deprecated methods that have no alternative - does not register an offense when using `__ENCODING__ - registers and corrects an offense when using `NIL` - registers and corrects an offense when using `TRUE` - registers and corrects an offense when using `FALSE` - registers and corrects an offense when using `::FALSE` - registers and corrects an offense when using `::TRUE` - registers and corrects an offense when using `::NIL` - Ruby <= 2.5 - does not register an offense when using `Net::HTTPServerException` +RuboCop::Cop::Lint::AmbiguousRegexpLiteral Ruby >= 3.0 - registers and corrects an offense when using `Random::DEFAULT` - registers and corrects an offense when using `::Random::DEFAULT` - Ruby >= 2.6 - registers and corrects an offense when using `Net::HTTPServerException` + with parentheses + accepts + with `match_with_lvasgn` node + with different parentheses + does not register an offense + without parentheses + registers an offense and corrects + with parentheses + does not register an offense + without parentheses + registers an offense and corrects when using regexp without method call in a nested structure + registers an offense and corrects when sending method to regexp without argument + registers an offense and corrects when sending method chain to regexp + registers an offense and corrects when nesting + registers an offense and corrects when using block argument + registers an offense and corrects when using nested method arguments without parentheses + registers an offense and corrects when sending method without receiver takes a regexp argument + registers an offense and corrects when sending method inside parens without receiver takes a regexp argument + registers an offense and corrects when single argument + registers an offense and corrects when multiple arguments + registers an offense and corrects when sending method to regexp with argument Ruby <= 2.7 - does not register an offense when using `Random::DEFAULT` + without parentheses + registers an offense and corrects when single argument + registers an offense and corrects when nesting + registers an offense and corrects when sending method chain to regexp + registers an offense and corrects when multiple arguments + registers an offense and corrects when sending method without receiver takes a regexp argument + registers an offense and corrects when using block argument + registers an offense and corrects when using regexp without method call in a nested structure + registers an offense and corrects when sending method inside parens without receiver takes a regexp argument + registers an offense and corrects when sending method to regexp with argument + registers an offense and corrects when sending method to regexp without argument + registers an offense and corrects when using nested method arguments without parentheses + with parentheses + accepts + with `match_with_lvasgn` node + with parentheses + does not register an offense + without parentheses + registers an offense and corrects + with different parentheses + does not register an offense -RuboCop::Cop::Lint::NextWithoutAccumulator - behaves like reduce/inject - given a reduce block - registers an offense for a bare next - accepts next within a nested block - accepts next with a value - Ruby 2.7 - registers an offense for a bare next - behaves like reduce/inject - given a inject block - accepts next with a value - registers an offense for a bare next - accepts next within a nested block - Ruby 2.7 - registers an offense for a bare next - given an unrelated block - accepts a bare next - accepts next with a value +RuboCop::Cop::Lint::SafeNavigationChain + TargetRubyVersion >= 2.3 + accepts usages of ordinary method chain with argument + accepts usages of safe navigation with `present?` method + accepts usages of safe navigation at last only with argument + accepts usages of safe navigation with && operator + registers an offense for safe navigation with >= operator + accepts usages of safe navigation with assignment method + accepts usages of method chain with safe navigation only with argument + accepts usages of safe navigation with `-@` method + registers an offense for ordinary method call exists after safe navigation method call + accepts usages of ordinary method chain + accepts usages of safe navigation with `nil?` method + registers an offense for safe navigation on the right-hand side of the `*` + registers an offense for safe navigation with []= operator + accepts usages of safe navigation with `+@` method + accepts usages of safe navigation with `blank?` method + accepts usages of safe navigation at last only + registers an offense for safe navigation with + operator + accepts usages of safe navigation with `in?` method + registers an offense for safe navigation with [] operator + registers an offense for safe navigation with <= operator + registers an offense for ordinary method chain exists after safe navigation method call with a block-pass + accepts usages of safe navigation with `try` method + accepts usages of safe navigation with | operator + accepts usages of safe navigation with || operator + accepts usages of safe navigation with & operator + registers an offense for safe navigation on the right-hand side of the `/` + registers an offense for ordinary method chain exists after safe navigation method call with a block + accepts usages of safe navigation with self assignment method + accepts usages of safe navigation with `to_d` method + registers an offense for ordinary method call exists after safe navigation method call with an argument + registers an offense for ordinary method chain exists after safe navigation method call with an argument + accepts usages of method chain with safe navigation only + accepts usages of safe navigation with === operator + registers an offense for ordinary method chain exists after safe navigation method call + accepts usages of safe navigation with == operator + registers an offense for safe navigation on the right-hand side of the `-` + registers an offense for safe navigation with > operator + registers an offense for safe navigation on the right-hand side of the `+` + registers an offense for safe navigation with < operator + proper highlighting + when used with a modifier if + when there are methods before + when there are methods after + when in a method + when in a begin + >= Ruby 2.7 + registers an offense for ordinary method chain exists after safe navigation method call with a block using numbered parameter -RuboCop::Cop::Style::ClassAndModuleChildren - compact style - registers a offense for classes with nested one-liner children - correctly indents heavily nested children - accepts compact style for classes/modules - registers a offense for classes with nested children - registers an offense for modules with partially nested children - accepts nesting for classes with an explicit superclass - accepts nesting for classes/modules with more than one child - registers a offense for modules with nested children - accepts class/module with single method - registers and offense for deeply nested children - preserves comments between classes - registers an offense for classes with partially nested children - nested style - accepts :: in parent class on inheritance - registers an offense for partially nested classes - registers an offense for not nested classes when namespace is defined as a class - registers an offense for not nested classes when namespace is defined as a module - accepts nested children - registers an offense for not nested classes - registers an offense for partially nested modules - registers an offense for not nested modules - preserves comments - accepts cbase module name - registers an offense for not nested classes with explicit superclass - accepts cbase class name +RuboCop::Cop::Style::TrailingBodyOnClass + autocorrects with comment after body + accepts class inheritance + accepts regular class + registers an offense when body trails after class definition + registers offense with multi-line class + when class is not on first line of processed_source + autocorrect offense -RuboCop::Cop::Metrics::BlockNesting - accepts if/elsif - accepts `Max` levels of nesting - when CountBlocks is true - nested inline block - registers an offense - nested multiline block +RuboCop::Cop::InternalAffairs::NumblockHandler + does not register an offense for cops with on_numblock method + registers an offense for cops with forgotten numblock handlers + does not register an offense for cops with on_numblock alias_method + does not register an offense for cops with on_numblock alias + +RuboCop::Cop::Bundler::OrderedGems + when a gem is referenced from a variable + resets the sorting to a new block + ignores the line + When a gem is sorted but not so when disregarding _- + by default registers an offense - nested `while` - registers an offense - `Max + 1` levels of `if` nesting - registers an offense - `Max + 2` levels of `if` nesting - registers an offense - nested `case` - registers an offense - nested `rescue` - registers an offense - Multiple nested `ifs` at same level - registers 2 offenses - nested modifier `until` - registers an offense - nested `for` + when ConsiderPunctuation is true + does not register an offense + When there are duplicated gems in group registers an offense - nested `until` + When a gem that starts with a capital letter is not sorted registers an offense - when CountBlocks is false - accepts nested multiline blocks - accepts nested inline blocks - nested modifier `while` + When the gemfile is empty + does not register any offenses + When each individual group of line is not sorted + registers some offenses + When gems are not alphabetically sorted registers an offense - -RuboCop::Server::Cache - .cache_path - when `RUBOCOP_CACHE_ROOT` environment variable is set - when cache root path is specified path - contains the root from cache root path - when cache root path is not specified path - contains the root from `RUBOCOP_CACHE_ROOT` - when cache root path is not specified path and `XDG_CACHE_HOME` environment variable is specified - contains the root from `RUBOCOP_CACHE_ROOT` - when cache root path is not specified as default - is the default path - when ERB pre-processing of the configuration file - when cache root path is not specified path - does not raise an error - when .rubocop.yml is empty - when cache root path is not specified path - does not raise an error - when `CacheRootDirectory` configure value is set - when cache root path is not specified path - contains the root from `CacheRootDirectory` configure value - when cache root path is not specified path and `XDG_CACHE_HOME` environment variable is spacified - contains the root from `CacheRootDirectory` configure value - when cache root path is specified path - contains the root from cache root path - when cache root path is specified path - is the specified path - when `XDG_CACHE_HOME` environment variable is set - when cache root path is not specified path - contains the root from `XDG_CACHE_HOME` - when cache root path is specified path - contains the root from cache root path - .pid_running? - works properly when concurrency with server stopping and cleaning cache dir - -RuboCop::Cop::Style::ObjectThen - EnforcedStyle: yield_self - accepts then without a block - accepts then with more than 1 param - registers an offense for then with proc param - registers an offense for then with block - EnforcedStyle: then - registers an offense for yield_self with proc param - accepts yield_self with more than 1 param - accepts yield_self without a block - Ruby 2.5 - accepts yield_self with block - Ruby 2.6 - registers an offense for yield_self with block - Ruby 2.7 - registers an offense for yield_self with block - -RuboCop::Cop::Layout::IndentationConsistency - with unless - registers an offense and corrects bad indentation in an unless body - accepts an empty unless - with block - registers an offense and correct bad indentation in a do/end body - registers an offense and corrects bad indentation in a {} body - does not autocorrect an offense within another offense - accepts an empty block body - accepts a correctly indented block body - with for - accepts an empty for - registers an offense and corrects bad indentation in a for body - with def/defs - registers an offense and corrects bad indentation in a defs body - registers an offense and corrects bad indentation in a def body - accepts an empty defs body - accepts an empty def body - with while/until - registers an offense and corrects bad indentation in begin/end/while - registers an offense and corrects bad indentation in a while body - registers an offense and corrects bad indentation in an until body - accepts an empty while - with top-level code - registers and corrects an offense when using access modifier and indented method definition at the top level - accepts an empty expression string interpolation - accepts when using access modifier at the top level - with case - registers an offense and corrects bad indentation in a case/when body - accepts case/when/else laid out as a table - accepts correctly indented case/when/else - registers an offense and corrects bad indentation in a case/else body - accepts indented when/else plus indented body - accepts case/when/else with then beginning a line - with if statement - accepts an empty if - accepts an if in assignment with end aligned with if - accepts a correctly aligned if/elsif/else/end - registers an offense and corrects bad indentation in an if body - accepts a one line if statement - accepts if/elsif/else/end with fullwidth characters - accepts if/elsif/else/end laid out as a table - accepts if/then/else/end laid out as another table - registers an offense and corrects bad indentation in an else body - accepts an if/else in assignment with end aligned with variable - accepts an if/else in assignment with end aligned with variable and chaining after the end - accepts an if/else in assignment with end aligned with variable and chaining with a block after the end - accepts an if/else branches with rescue clauses - accepts an if in assignment with end aligned with variable - accepts an if/else in assignment with end aligned with if - registers an offense and corrects bad indentation in an elsif body - accepts an if/else in assignment on next line with end aligned with if - with module - registers an offense and corrects bad indentation of private methods - registers an offense and corrects bad indentation in a module body - accepts an empty module body - even when there are no public methods - registers an offense and corrects bad indentation of private methods - with class - with indented_internal_methods style configured - accepts different indentation in different visibility sections when using `Struct.new` - accepts different indentation in different visibility sections - with normal style configured - registers an offense and corrects bad indentation in a class body - accepts an empty class body - registers an offense and corrects bad indentation in def but not for outdented public, protected, and private - accepts indented public, protected, and private - -RuboCop::Cop::Style::PercentLiteralDelimiters - `%q` string - does not register an offense for other delimiters when containing preferred delimiter characters - registers an offense for other delimiters - does not register an offense for preferred delimiters - `%W` interpolated string array - does not register an offense for other delimiters when containing preferred delimiter characters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - does not register an offense for preferred delimiters - registers an offense for other delimiters - autocorrect - preserves indentation when correcting a multiline array - preserves line breaks when fixing a multiline array - fixes a string array in a scope - preserves irregular indentation when correcting a multiline array - behaves like escape characters - corrects %x with \n in it - corrects %x with \t in it - behaves like escape characters - corrects %r with \t in it - corrects %r with \n in it - behaves like escape characters - corrects %i with \t in it - corrects %i with \n in it - behaves like escape characters - corrects %w with \n in it - corrects %w with \t in it - behaves like escape characters - corrects % with \t in it - corrects % with \n in it - behaves like escape characters - corrects %q with \t in it - corrects %q with \n in it - behaves like escape characters - corrects %W with \n in it - corrects %W with \t in it - behaves like escape characters - corrects %s with \n in it - corrects %s with \t in it - behaves like escape characters - corrects %Q with \t in it - corrects %Q with \n in it - `%Q` interpolated string - does not register an offense for other delimiters when containing preferred delimiter characters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - registers an offense for other delimiters - does not register an offense for preferred delimiters - `%s` symbol - registers an offense for other delimiters - does not register an offense for preferred delimiters - `%i` symbol array - does not register an offense for non-preferred delimiters enclosing escaped delimiters - registers an offense for other delimiters - does not register an offense for preferred delimiters - `%` interpolated string - does not register an offense for other delimiters when containing preferred delimiter characters - registers an offense when the source contains invalid characters - registers an offense for a string with no content - registers an offense for other delimiters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - does not register an offense for preferred delimiters - `%r` interpolated regular expression - does not register an offense for preferred delimiters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - registers an offense for a regular expression with option - registers an offense for other delimiters - does not register an offense for other delimiters when containing preferred delimiter characters - `%w` string array - does not register an offense for preferred delimiters with only a closing delimiter - does not register an offense for preferred delimiters with a pairing delimiters - does not register an offense for other delimiters when containing preferred delimiter characters - does not register an offense for preferred delimiters - does not register an offense for preferred delimiters with not a pairing delimiter - registers an offense for other delimiters - `default` override - allows all preferred delimiters to be set with one key - allows individual preferred delimiters to override `default` - invalid cop config - raises an error when invalid configuration is specified - `%I` interpolated symbol array - registers an offense for other delimiters - does not register an offense for preferred delimiters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - `%x` interpolated system call - does not register an offense for preferred delimiters - does not register an offense for other delimiters when containing preferred delimiter characters - registers an offense for other delimiters - registers an offense for other delimiters when containing preferred delimiter characters in interpolation - -RuboCop::Cop::Style::WhileUntilDo - accepts multi-line while without do - registers an offense for do in multiline until - accepts do in single-line until - accepts multi-line until without do - registers an offense for do in multiline while - accepts do in single-line while - -RuboCop::Cop::Lint::UselessAccessModifier - behaves like nested in a begin..end block - doesn't flag an access modifier from surrounding scope - still flags repeated `private` - behaves like nested modules - doesn't register an offense for nested classs - unused modifiers - registers an offense with a nested class - registers an offense when inside a nested class - registers an offense when outside a nested class - behaves like method defined with define_method - doesn't register an offense if a proc is passed - doesn't register an offense if a -> is passed - doesn't register an offense if a block is passed - doesn't register an offense if a lambda is passed - behaves like def in new block - registers an offense if no method is defined in Struct.new - doesn't register an offense if a method is defined in Struct.new - behaves like def in new block - doesn't register an offense if a method is defined in ::Struct.new - registers an offense if no method is defined in ::Struct.new - behaves like repeated visibility modifiers - registers an offense when `private` is repeated - behaves like method defined using class_eval - registers an offense if no method is defined - doesn't register an offense if a method is defined - inside a class - registers an offense when a modifier is outside the block and a method is defined only inside the block - registers two offenses when a modifier is inside and outside the block and no method is defined - behaves like methods defined in an iteration - doesn't register an offense for map - doesn't register an offense for each - when using ActiveSupport behavior when Rails is not eabled - reports offenses and corrects - behaves like nested modules - doesn't register an offense for nested modules - unused modifiers - registers an offense when inside a nested module - registers an offense when outside a nested module - registers an offense with a nested module - behaves like at the end of the body - registers an offense for trailing `public` - behaves like method defined with define_method - doesn't register an offense if a lambda is passed - doesn't register an offense if a proc is passed - doesn't register an offense if a -> is passed - doesn't register an offense if a block is passed - behaves like repeated visibility modifiers - registers an offense when `private` is repeated - behaves like def in new block - doesn't register an offense if a method is defined in Class.new - registers an offense if no method is defined in Class.new - when private_class_method is used without arguments - registers an offense and corrects - behaves like nested modules - doesn't register an offense for nested modules - unused modifiers - registers an offense with a nested module - registers an offense when outside a nested module - registers an offense when inside a nested module - behaves like method named by access modifier name - does not register an offense for `private` - behaves like def in new block - doesn't register an offense if a method is defined in ::Module.new - registers an offense if no method is defined in ::Module.new - when private_class_method is used with arguments - does not register an offense - behaves like method defined with define_method - doesn't register an offense if a proc is passed - doesn't register an offense if a lambda is passed - doesn't register an offense if a -> is passed - doesn't register an offense if a block is passed - behaves like def in new block - doesn't register an offense if a method is defined in Module.new - registers an offense if no method is defined in Module.new - behaves like non-repeated visibility modifiers - doesn't register an offense when `protected` is not repeated - registers an offense and corrects even when `public` is not repeated - doesn't register an offense when `private` is not repeated - behaves like repeated visibility modifiers - registers an offense when `protected` is repeated - behaves like conditionally defined method - doesn't register an offense for if - doesn't register an offense for unless - when an access modifier has no effect - registers an offense and corrects - behaves like def in new block - doesn't register an offense if a method is defined in Module.new - registers an offense if no method is defined in Module.new - behaves like repeated visibility modifiers - registers an offense when `protected` is repeated - behaves like method named by access modifier name - does not register an offense for `public` - behaves like repeated visibility modifiers - registers an offense when `public` is repeated - behaves like conditionally defined method - doesn't register an offense for unless - doesn't register an offense for if - when passing method as symbol - does not register an offense - behaves like at the end of the body - registers an offense for trailing `private` - behaves like nested in a begin..end block - doesn't flag an access modifier from surrounding scope - still flags repeated `protected` - behaves like def in new block - doesn't register an offense if a method is defined in ::Module.new - registers an offense if no method is defined in ::Module.new - behaves like method named by access modifier name - does not register an offense for `protected` - behaves like methods defined in an iteration - doesn't register an offense for each - doesn't register an offense for map - when an access modifier is followed by attr_* - does not register an offense - behaves like method defined using instance_eval - registers an offense if no method is defined - doesn't register an offense if a method is defined - inside a class - registers two offenses when a modifier is inside and outside the and no method is defined - registers an offense when a modifier is outside the block and a method is defined only inside the block - behaves like nested modules - doesn't register an offense for nested classs - unused modifiers - registers an offense with a nested class - registers an offense when outside a nested class - registers an offense when inside a nested class - behaves like def in new block - registers an offense if no method is defined in Struct.new - doesn't register an offense if a method is defined in Struct.new - behaves like method defined using instance_eval - registers an offense if no method is defined - doesn't register an offense if a method is defined - inside a class - registers two offenses when a modifier is inside and outside the and no method is defined - registers an offense when a modifier is outside the block and a method is defined only inside the block - behaves like method defined with define_method - doesn't register an offense if a block is passed - doesn't register an offense if a -> is passed - doesn't register an offense if a proc is passed - doesn't register an offense if a lambda is passed - when there are consecutive access modifiers - registers an offense and corrects - behaves like nested in a begin..end block - still flags repeated `private` - doesn't flag an access modifier from surrounding scope - when using inline modifiers + When a gem that starts with a capital letter is sorted does not register an offense - when multiple class definitions in file but only one has offense - registers an offense and corrects - behaves like conditionally defined method - doesn't register an offense for unless - doesn't register an offense for if - when an access modifier is followed by a class method defined on constant - registers an offense and corrects - behaves like def in new block - registers an offense if no method is defined in ::Class.new - doesn't register an offense if a method is defined in ::Class.new - behaves like def in new block - doesn't register an offense if a method is defined in Class.new - registers an offense if no method is defined in Class.new - behaves like unused visibility modifiers - registers an offense and corrects when visibility is immediately changed without any intervening defs - behaves like def in new block - doesn't register an offense if a method is defined in ::Class.new - registers an offense if no method is defined in ::Class.new - behaves like conditionally defined method - doesn't register an offense for if - doesn't register an offense for unless - behaves like nested in a begin..end block - doesn't flag an access modifier from surrounding scope - still flags repeated `protected` - when using ActiveSupport's `concerning` method - is aware that this creates a new scope - still points out redundant uses within the block - Ruby 2.7 - still points out redundant uses within the block - behaves like at the top of the body - doesn't register an offense for `protected` - doesn't register an offense for `private` - registers an offense and corrects for `public` - behaves like method defined on a singleton class - outside a class - doesn't register an offense if a method is defined - registers an offense if no method is defined after the modifier - registers an offense if no method is defined - inside a class - registers an offense if no method is defined - registers an offense even if a non-singleton-class method is defined - doesn't register an offense if the modifier is the same as outside the meta-class - registers an offense if no method is defined after the modifier - doesn't register an offense if a method is defined - behaves like def in new block - registers an offense if no method is defined in ::Struct.new - doesn't register an offense if a method is defined in ::Struct.new - behaves like methods defined in an iteration - doesn't register an offense for map - doesn't register an offense for each - behaves like nested in a begin..end block - still flags repeated `public` - behaves like method defined using class_eval - doesn't register an offense if a method is defined - registers an offense if no method is defined - inside a class - registers an offense when a modifier is outside the block and a method is defined only inside the block - registers two offenses when a modifier is inside and outside the block and no method is defined - behaves like method named by access modifier name - does not register an offense for `protected` - behaves like at the end of the body - registers an offense for trailing `private` - behaves like non-repeated visibility modifiers - registers an offense and corrects even when `public` is not repeated - doesn't register an offense when `private` is not repeated - doesn't register an offense when `protected` is not repeated - behaves like at the end of the body - registers an offense for trailing `protected` - behaves like method defined on a singleton class - outside a class - registers an offense if no method is defined after the modifier - doesn't register an offense if a method is defined - registers an offense if no method is defined - inside a class - registers an offense even if a non-singleton-class method is defined - doesn't register an offense if the modifier is the same as outside the meta-class - registers an offense if no method is defined - registers an offense if no method is defined after the modifier - doesn't register an offense if a method is defined - when class is empty save modifier - registers an offense and corrects - when an access modifier has no methods - registers an offense and corrects - behaves like method defined on a singleton class - outside a class - registers an offense if no method is defined - doesn't register an offense if a method is defined - registers an offense if no method is defined after the modifier - inside a class - doesn't register an offense if the modifier is the same as outside the meta-class - registers an offense if no method is defined after the modifier - registers an offense if no method is defined - doesn't register an offense if a method is defined - registers an offense even if a non-singleton-class method is defined - behaves like unused visibility modifiers - registers an offense and corrects when visibility is immediately changed without any intervening defs - behaves like at the end of the body - registers an offense for trailing `protected` - behaves like repeated visibility modifiers - registers an offense when `public` is repeated - behaves like method named by access modifier name - does not register an offense for `public` - when using the class_methods method from ActiveSupport::Concern - is aware that this creates a new scope - behaves like methods defined in an iteration - doesn't register an offense for each - doesn't register an offense for map - when a def is an argument to a method call + When a gem declaration takes several lines + registers an offense + When gems are asciibetically sorted irrespective of _ does not register an offense - behaves like nested in a begin..end block - still flags repeated `public` - behaves like method named by access modifier name - does not register an offense for `private` - when only a constant or local variable is defined after the modifier - registers an offense and corrects - registers an offense and corrects - behaves like method defined on a singleton class - inside a class - registers an offense if no method is defined after the modifier - doesn't register an offense if the modifier is the same as outside the meta-class - registers an offense even if a non-singleton-class method is defined - doesn't register an offense if a method is defined - registers an offense if no method is defined - outside a class - registers an offense if no method is defined after the modifier - doesn't register an offense if a method is defined - registers an offense if no method is defined - behaves like at the top of the body - doesn't register an offense for `private` - registers an offense and corrects for `public` - doesn't register an offense for `protected` - behaves like at the end of the body - registers an offense for trailing `public` - when using a known method-creating method - is aware that this creates a new method - still points out redundant uses within the module - -RuboCop::Cop::InternalAffairs::NodeDestructuring - registers an offense when destructuring using a splat - does not register an offense when receiver is named `array` - when destructuring using `node.children` - registers an offense when receiver is named `send_node` - registers an offense when receiver is named `node` - -RuboCop::Cop::Style::RegexpLiteral - when PercentLiteralDelimiters is configured with brackets - respects the configuration when autocorrecting - when `EnforcedStyle: omit_parentheses` of `Style/MethodCallWithArgsParentheses` cop - when using `%r` regexp with `EnforcedStyle: slashes` - does not register an offense when used as a safe navigation method argument - does not register an offense when used as a method argument - registers an offense when not used as a method argument - when using `%r` regexp with `EnforcedStyle: mixed` - does not register an offense when used as a method argument - registers an offense when not used as a method argument - does not register an offense when used as a safe navigation method argument - when PercentLiteralDelimiters is configured with slashes - respects the configuration when autocorrecting - when EnforcedStyle is set to mixed - a single-line %r regex without slashes - registers an offense - a single-line `//` regex with slashes - registers an offense - when configured to allow inner slashes - is accepted - a multi-line `//` regex with slashes - registers an offense - a multi-line %r regex with slashes - is accepted - a multi-line %r regex without slashes - is accepted - a multi-line `//` regex without slashes - registers an offense - a single-line `//` regex without slashes - is accepted - a single-line %r regex with slashes - is accepted - when configured to allow inner slashes - registers an offense - when EnforcedStyle is set to percent_r - a multi-line `//` regex with slashes - registers an offense - a single-line `//` regex with slashes - registers an offense - a single-line `//` regex without slashes - registers an offense - a multi-line %r regex without slashes - is accepted - a multi-line %r regex with slashes - is accepted - a single-line %r regex with slashes - is accepted - a single-line %r regex without slashes - is accepted - a multi-line `//` regex without slashes - registers an offense - when `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` cop - when using `%r` regexp with `EnforcedStyle: slashes` - does not register an offense when using a regexp starts with a blank as a method argument - registers an offense when used as a method argument - registers an offense when using a regexp starts with a blank - registers an offense when not used as a method argument - registers an offense when used as a safe navigation method argument - does not register an offense when using a regexp starts with a blank as a safe navigation method argument - when using `%r` regexp with `EnforcedStyle: mixed` - does not register an offense when using a regexp starts with a blank as a method argument - registers an offense when used as a method argument - registers an offense when not used as a method argument - does not register an offense when using a regexp starts with a blank as a safe navigation method argument - registers an offense when using a regexp starts with a blank - registers an offense when used as a safe navigation method argument - when regex contains slashes in interpolation - ignores the slashes that do not belong // regex - %r regex with other delimiters than curly braces + When each individual group of line is sorted + does not register any offenses + When gems have an inline comment, and not sorted registers an offense - when EnforcedStyle is set to slashes - a single-line %r regex without slashes - registers an offense - a single-line %r regex with slashes - is accepted - when configured to allow inner slashes - registers an offense - a single-line `%r//` regex with slashes - is accepted - when configured to allow inner slashes - preserves slashes after autocorrection - a multi-line %r regex with slashes - is accepted - when configured to allow inner slashes - registers an offense - a single-line `//` regex without slashes - is accepted - a multi-line `//` regex with slashes - registers an offense - when configured to allow inner slashes - is accepted - a multi-line %r regex without slashes - registers an offense - a single-line `//` regex with slashes and interpolation - registers an offense - when configured to allow inner slashes - is accepted - a single-line `//` regex with slashes + When gem groups is separated by multiline comment + with TreatCommentsAsGroupSeparators: false registers an offense - when configured to allow inner slashes - is accepted - a multi-line `//` regex without slashes - is accepted - -RuboCop::Cop::Security::Open - registers an offense for `URI.open` with a block - accepts open with prefix string literal plus something - accepts open with a string that interpolates a literal - accepts File.open as method - registers an offense for open - registers an offense for `URI.open` with string that starts with a pipe - accepts open with string that has a prefixed interpolation - accepts open on a literal string - registers an offense for open with mode argument - registers an offense for open with dynamic string that is not prefixed - registers an offense for `::URI.open` with string that starts with a pipe - registers an offense for open with a block - accepts open with a literal string starting with a pipe - registers an offense for open with string that starts with a pipe - accepts open as variable - accepts open with no arguments - -RuboCop::Cop::Style::CaseLikeIf - registers an offense and corrects when using `==` with literal - registers an offense and corrects when using `==` with constant - does not register an offense when only single `if` - registers an offense and corrects when using `match?` with regexp - registers an offense and corrects when using `is_a?` - registers an offense and corrects when using `match?` with non regexp in other branches except first - does not register an offense when using `match?` without a receiver - does not register an offense when not all conditions contain target - does not register an offense when using modifier `if` - does not register an offense when using `==` with constant containing 1 letter in name - does not register an offense when using `cover?` without a receiver - registers an offense and corrects when using `=~` - registers an offense and corrects when using nested conditions with `||` - does not register an offense when using ternary operator - does not register an offense when one of `||` subconditions is not convertible - does not register an offense when using `==` with method call with arguments - does not register an offense when using `unless` - does not register an offense when using `include?` without a receiver - registers an offense and corrects when using `===` - registers an offense and corrects when target is a method call - does not register an offense when using `match?` with non regexp - registers an offense and corrects when using `include?` with range - registers an offense and corrects when using `||` within conditions - does not register an offense when an object overrides `equal?` with no arity - does not register an offense when using `equal?` without a receiver - does not register an offense when using `match?` in first branch with non regexp - does not register an offense when only `if-else` - does not register an offense when using `=~` in first branch with non regexp - does not register an offense when one of the branches contains `==` with class reference - does not register an offense when using `==` with class reference - when using regexp with named captures - does not register an offense with match and regexp on rhs - does not register an offense with =~ and regexp on lhs - registers and corrects an offense with match? and regexp on lhs - does not register an offense with match and regexp on lhs - registers and corrects an offense with =~ and regexp on rhs - registers and corrects an offense with match? and regexp on rhs - -RuboCop::Cop::Style::MutableConstant - Strict: false - allows method call assignments - behaves like immutable objects - allows ::ENV['foo'] to be ||= to a constant - allows ::ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - when assigning an array without brackets - adds brackets when autocorrecting - does not insert brackets for %w() arrays - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like string literal - Ruby 3.0 or higher - when the frozen string literal comment is missing - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is true - registers an offense when using interpolated heredoc constant - does not register an offense when using a multiline string - registers an offense when using a multiline string with interpolation - behaves like mutable objects - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows <<~HERE - foo - bar -HERE - to be assigned to a constant - allows <<~HERE - foo - bar -HERE - to be ||= to a constant - when the frozen string literal comment is false - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - Ruby 2.7 or lower - when the frozen string literal comment is false - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is missing - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is true - does not register an offense when using a multiline string - does not register an offense when using interpolated heredoc constant - behaves like immutable objects - allows "#{a}" to be assigned to a constant - allows "#{a}" to be ||= to a constant - behaves like immutable objects - allows <<~HERE - foo - bar -HERE - to be ||= to a constant - allows <<~HERE - foo - bar -HERE - to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 'foo' + 'bar' to be assigned to a constant - allows 'foo' + 'bar' to be ||= to a constant - behaves like immutable objects - allows FOO - BAR to be assigned to a constant - allows FOO - BAR to be ||= to a constant - splat expansion - expansion of a range - registers an offense and corrects to use to_a.freeze - with parentheses - registers an offense and corrects to use to_a.freeze - behaves like mutable objects - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like immutable objects - allows ENV['foo'] to be assigned to a constant - allows ENV['foo'] to be ||= to a constant - Ruby 3.0 or higher - raises offense only for shareable_constant_value as none when set in the order of: literal, none and experimental_everything - raises offense when shareable_constant_value is specified as an inline comment - when using shareable_constant_value - behaves like literals that are frozen - behaves like immutable objects - allows [1, 2, 3] to be assigned to a constant - allows [1, 2, 3] to be ||= to a constant - behaves like immutable objects - allows { a: 1, b: 2 } to be assigned to a constant - allows { a: 1, b: 2 } to be ||= to a constant - behaves like immutable objects - allows FOO - BAR to be ||= to a constant - allows FOO - BAR to be assigned to a constant - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be ||= to a constant - allows 'foo' + 'bar' to be assigned to a constant - behaves like immutable objects - allows "top#{1 + 2}" to be ||= to a constant - allows "top#{1 + 2}" to be assigned to a constant - behaves like immutable objects - allows ::ENV['foo'] to be ||= to a constant - allows ::ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows %w(a b c) to be assigned to a constant - allows %w(a b c) to be ||= to a constant - behaves like immutable objects - allows 'str' to be assigned to a constant - allows 'str' to be ||= to a constant - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like literals that are not frozen - behaves like immutable objects - allows 1.5 to be ||= to a constant - allows 1.5 to be assigned to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be assigned to a constant - allows 'foo' + 'bar' to be ||= to a constant - behaves like immutable objects - allows FOO - BAR to be ||= to a constant - allows FOO - BAR to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1 to be ||= to a constant - allows 1 to be assigned to a constant - behaves like immutable objects - allows FOO + BAR to be assigned to a constant - allows FOO + BAR to be ||= to a constant - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - behaves like immutable objects - allows ::ENV['foo'] to be ||= to a constant - allows ::ENV['foo'] to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like literals that are frozen - behaves like immutable objects - allows %w(a b c) to be ||= to a constant - allows %w(a b c) to be assigned to a constant - behaves like immutable objects - allows :sym to be ||= to a constant - allows :sym to be assigned to a constant - behaves like immutable objects - allows [1, 2, 3] to be ||= to a constant - allows [1, 2, 3] to be assigned to a constant - behaves like immutable objects - allows 1 to be ||= to a constant - allows 1 to be assigned to a constant - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows "top#{1 + 2}" to be ||= to a constant - allows "top#{1 + 2}" to be assigned to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be assigned to a constant - allows 'foo' + 'bar' to be ||= to a constant - behaves like immutable objects - allows { a: 1, b: 2 } to be ||= to a constant - allows { a: 1, b: 2 } to be assigned to a constant - behaves like immutable objects - allows ::ENV['foo'] to be assigned to a constant - allows ::ENV['foo'] to be ||= to a constant - behaves like immutable objects - allows FOO - BAR to be assigned to a constant - allows FOO - BAR to be ||= to a constant - behaves like immutable objects - allows 'str' to be assigned to a constant - allows 'str' to be ||= to a constant - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like literals that are frozen - behaves like immutable objects - allows ENV['foo'] to be assigned to a constant - allows ENV['foo'] to be ||= to a constant - behaves like immutable objects - allows %w(a b c) to be ||= to a constant - allows %w(a b c) to be assigned to a constant - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like immutable objects - allows ::ENV['foo'] to be assigned to a constant - allows ::ENV['foo'] to be ||= to a constant - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - behaves like immutable objects - allows { a: 1, b: 2 } to be assigned to a constant - allows { a: 1, b: 2 } to be ||= to a constant - behaves like immutable objects - allows 1.5 to be ||= to a constant - allows 1.5 to be assigned to a constant - behaves like immutable objects - allows 1 to be ||= to a constant - allows 1 to be assigned to a constant - behaves like immutable objects - allows [1, 2, 3] to be assigned to a constant - allows [1, 2, 3] to be ||= to a constant - behaves like immutable objects - allows 'str' to be assigned to a constant - allows 'str' to be ||= to a constant - behaves like immutable objects - allows FOO - BAR to be assigned to a constant - allows FOO - BAR to be ||= to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be ||= to a constant - allows 'foo' + 'bar' to be assigned to a constant - behaves like immutable objects - allows "top#{1 + 2}" to be ||= to a constant - allows "top#{1 + 2}" to be assigned to a constant - when assigning a range (irange) - does not register an offense when with parenthesis - does not register an offense when without parenthesis - when assigning a regexp - does not register an offense - when assigning a range (erange) - does not register an offense when without parenthesis - does not register an offense when with parenthesis - behaves like mutable objects - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - Ruby 2.7 or lower - when assigning a range (irange) without parenthesis - adds parentheses when autocorrecting - does not insert parenthesis to range enclosed in parentheses - when assigning a range (erange) without parenthesis - does not insert parenthesis to range enclosed in parentheses - adds parentheses when autocorrecting - when assigning a regexp - registers an offense - when using shareable_constant_values - behaves like literals that are not frozen - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like immutable objects - allows ::ENV['foo'] to be assigned to a constant - allows ::ENV['foo'] to be ||= to a constant - behaves like mutable objects - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows :sym to be ||= to a constant - allows :sym to be assigned to a constant - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows FOO - BAR to be assigned to a constant - allows FOO - BAR to be ||= to a constant - behaves like mutable objects - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be assigned to a constant - allows 'foo' + 'bar' to be ||= to a constant - behaves like mutable objects - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows FOO + BAR to be assigned to a constant - allows FOO + BAR to be ||= to a constant - behaves like literals that are not frozen - behaves like mutable objects - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - behaves like mutable objects - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ENV['foo'] to be assigned to a constant - allows ENV['foo'] to be ||= to a constant - behaves like immutable objects - allows FOO + BAR to be assigned to a constant - allows FOO + BAR to be ||= to a constant - behaves like immutable objects - allows ::ENV['foo'] to be ||= to a constant - allows ::ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be ||= to a constant - allows 'foo' + 'bar' to be assigned to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows FOO - BAR to be ||= to a constant - allows FOO - BAR to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like literals that are not frozen - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ::ENV['foo'] to be assigned to a constant - allows ::ENV['foo'] to be ||= to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows FOO - BAR to be ||= to a constant - allows FOO - BAR to be assigned to a constant - behaves like immutable objects - allows 1.5 to be ||= to a constant - allows 1.5 to be assigned to a constant - behaves like immutable objects - allows :sym to be ||= to a constant - allows :sym to be assigned to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 'foo' + 'bar' to be ||= to a constant - allows 'foo' + 'bar' to be assigned to a constant - behaves like immutable objects - allows 1 to be ||= to a constant - allows 1 to be assigned to a constant - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like literals that are not frozen - behaves like immutable objects - allows FOO - BAR to be assigned to a constant - allows FOO - BAR to be ||= to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ::ENV['foo'] to be ||= to a constant - allows ::ENV['foo'] to be assigned to a constant - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows :sym to be ||= to a constant - allows :sym to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1.5 to be ||= to a constant - allows 1.5 to be assigned to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows FOO + BAR to be ||= to a constant - allows FOO + BAR to be assigned to a constant - behaves like immutable objects - allows 'foo' + 'bar' to be assigned to a constant - allows 'foo' + 'bar' to be ||= to a constant - behaves like immutable objects - allows ENV['foo'] to be ||= to a constant - allows ENV['foo'] to be assigned to a constant - Strict: true - allows calls to freeze - freezes a heredoc - behaves like immutable objects - allows ::ENV['foo'] to be assigned to a constant - allows ::ENV['foo'] to be ||= to a constant - behaves like immutable objects - allows 1.5 to be assigned to a constant - allows 1.5 to be ||= to a constant - behaves like immutable objects - allows :sym to be assigned to a constant - allows :sym to be ||= to a constant - behaves like mutable objects - when assigning with = - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows OTHER_CONST to be ||= to a constant - allows OTHER_CONST to be assigned to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows 1 to be assigned to a constant - allows 1 to be ||= to a constant - behaves like immutable objects - allows Struct.new(:a, :b) to be ||= to a constant - allows Struct.new(:a, :b) to be assigned to a constant - operators that produce unfrozen objects - registers an offense when operating on multiple strings - registers an offense when operating on a constant and a string - splat expansion - expansion of a range - registers an offense and corrects to use to_a.freeze - with parentheses - registers an offense and corrects to use to_a.freeze - when assigning with an operator - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like operator methods - registers an offense and corrects with parens and freeze - behaves like immutable objects - allows Struct.new(:node) do - def assignment? - true - end -end - to be ||= to a constant - allows Struct.new(:node) do - def assignment? - true - end -end - to be assigned to a constant - when assigning an array without brackets - adds brackets when autocorrecting - does not insert brackets for %w() arrays - behaves like mutable objects - when assigning with = - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ENV['foo'] to be assigned to a constant - allows ENV['foo'] to be ||= to a constant - behaves like mutable objects - when assigning with ||= - registers an offense for Something.new assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for Something.new assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with = - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for 'str' assigned to a constant and corrects by adding .freeze - behaves like mutable objects - when assigning with ||= - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze - methods and operators that produce frozen objects - accepts operating on a constant and an interger - accepts operating on a constant and a float - accepts assigning to an environment variable with a fallback - accepts operating on multiple floats - accepts operating on multiple integers - accepts comparison operators - accepts checking fixed size - behaves like immutable objects - allows Namespace::OTHER_CONST to be assigned to a constant - allows Namespace::OTHER_CONST to be ||= to a constant - behaves like string literal - Ruby 2.7 or lower - when the frozen string literal comment is true - does not register an offense when using a multiline string - does not register an offense when using interpolated heredoc constant - behaves like immutable objects - allows "#{a}" to be ||= to a constant - allows "#{a}" to be assigned to a constant - behaves like immutable objects - allows <<~HERE - foo - bar -HERE - to be assigned to a constant - allows <<~HERE - foo - bar -HERE - to be ||= to a constant - when the frozen string literal comment is missing - behaves like mutable objects - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is false - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - Ruby 3.0 or higher - when the frozen string literal comment is false - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is missing - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when the frozen string literal comment is true - does not register an offense when using a multiline string - registers an offense when using interpolated heredoc constant - registers an offense when using a multiline string with interpolation - behaves like immutable objects - allows <<~HERE - foo - bar -HERE - to be ||= to a constant - allows <<~HERE - foo - bar -HERE - to be assigned to a constant - behaves like mutable objects - when assigning with = - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - when assigning with ||= - registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze - behaves like immutable objects - allows ::Struct.new to be ||= to a constant - allows ::Struct.new to be assigned to a constant - when assigning with multiple operator calls - registers an offense and corrects with parens and freeze - behaves like immutable objects - allows ::OTHER_CONST to be ||= to a constant - allows ::OTHER_CONST to be assigned to a constant - behaves like immutable objects - allows ::Namespace::OTHER_CONST to be ||= to a constant - allows ::Namespace::OTHER_CONST to be assigned to a constant - behaves like immutable objects - allows Struct.new to be assigned to a constant - allows Struct.new to be ||= to a constant - -RuboCop::Cop::Layout::MultilineBlockLayout - registers an offense and corrects for missing newline in {} block with params - autocorrects nested parens correctly - does not register an offense for one-line do/end blocks - does not register offenses when there is a newline for {} block - registers an offense for missing newline in do/end block w/o params - registers an offense and corrects a line break within destructured arguments - registers an offense and corrects line-break before arguments with empty block - registers an offense and corrects for missing newline in do/end block with params - does not error out when the block is empty - considers the extra space required to join the lines together - registers an offense and corrects line-break before arguments - registers offenses when there are not too many parameters to fit on one line - registers offenses and corrects for new lambda literal syntax - doesn't move end keyword in a way which causes infinite loop in combination with Style/BlockEndNewLine - registers an offense and corrects for missing newline before opening parenthesis `(` for block body - does not register an offense for one-line {} blocks - does not register offenses when there is a newline for do/end block - registers an offense and corrects for missing newline in {} block w/o params - registers an offense and corrects a do/end block with a mult-line body - does not register offenses when there are too many parameters to fit on one line - registers an offense and corrects line-break within arguments - autocorrects in more complex case with lambda and assignment, and aligns the next line two spaces out from the start of the block - registers offenses and corrects for lambdas - registers an offense and corrects a line-break within arguments - does not remove a trailing comma when only one argument is present - Ruby 2.7 - registers an offense and corrects for missing newline in {} block w/o params - registers an offense and corrects for missing newline in do/end block with params - -RuboCop::Cop::Style::GuardClause - registers an error with next in the else branch - registers an offense when using `|| raise` in `else` branch - accepts a method which body does not end with if / unless - doesn't register an error if control flow expr has multiple lines - registers an offense when using `and return` in `else` branch - does not register an offense when assigning the result of a guard condition with `else` - accepts a method with empty parentheses as its body - registers an error with next in the if branch - doesn't register an error if control flow expr has multiple lines - registers an error with break in the if branch - does not report an offense if body is if..elsif..end - does not report an offense if break is inside if..elsif..else..end - does not report an offense if return is inside elsif - registers an offense when using `and return` in `then` branch - doesn't register an error if control flow expr has multiple lines - doesn't register an error if condition has multiple lines - registers an error with raise "error" in the if branch - registers an error with return in the if branch - registers an error if non-control-flow branch has multiple lines - does not report an offense if raise "error" is inside if..elsif..else..end - registers an error with raise "error" in the else branch - doesn't register an error if condition has multiple lines - accepts a method whose body is a modifier if / unless - registers an error if non-control-flow branch has multiple lines - doesn't register an error if condition has multiple lines - does not report an offense if next is inside elsif - does not report an offense if return is inside if..elsif..else..end - doesn't register an error if condition has multiple lines - does not report an offense if raise "error" is inside elsif - registers an error with return in the else branch - doesn't report an offense if condition has multiple lines - doesn't register an error if control flow expr has multiple lines - accepts a method which body is if / unless with else - does not report an offense if break is inside elsif - registers an error with break in the else branch - does not report an offense if next is inside if..elsif..else..end - registers an error if non-control-flow branch has multiple lines - registers an offense when using `|| raise` in `then` branch - registers an error if non-control-flow branch has multiple lines - Invalid MinBodyLength - fails with an error - AllowConsecutiveConditionals: false - reports an offense when not allowed same depth multiple if statement andpreceding expression is a conditional at the same depth - with Metrics/MaxLineLength enabled - when the correction is too long for a single line - with a trivial body - does not register an offense - with a nested `begin` node - does registers an offense - with a nested `if` node - does registers an offense - method in module - registers an offense for singleton methods - registers an offense for instance method - MinBodyLength: 4 - accepts a method whose body has 3 lines - AllowConsecutiveConditionals: true - reports an offense when allowed same depth multiple if statement andpreceding expression is not a conditional at the same depth - does not register an offense when allowed same depth multiple if statement andpreceding expression is not a conditional at the same depth - behaves like reports offense - reports an offense if method body is if / unless without else - reports an offense if method body ends with if / unless without else - behaves like reports offense - reports an offense if method body is if / unless without else - reports an offense if method body ends with if / unless without else - with Metrics/MaxLineLength disabled - registers an offense with modifier example code regardless of length - MinBodyLength: 1 - reports an offense for if whose body has 1 line + with TreatCommentsAsGroupSeparators: true + accepts + When gems are alphabetically sorted + does not register any offenses -RuboCop::Cop::Lint::UselessElseWithoutRescue - with `else` with `rescue` - accepts - with `else` without `rescue` - registers an offense +RuboCop::Cop::Layout::SpaceBeforeComma + registers an offense and corrects block argument with space before comma + does not register an offense for no spaces before comma + registers an offense and corrects array index with space before comma + handles more than one space before a comma + registers an offense and corrects method call arg with space before comma + heredocs + registers an offense and corrects -RuboCop::Cop::Gemspec::RequireMFA - when there are other metadata keys - and `rubygems_mfa_required` is included +RuboCop::Cop::Style::SingleArgumentDig + >= Ruby 2.7 + when using dig with arguments forwarding does not register an offense - and `rubygems_mfa_required` is not included - registers an offense and corrects - with rubygems_mfa_required: false by key access - registers an offense and corrects - when the gemspec is blank - does not register an offense - with rubygems_mfa_required: false - registers an offense and corrects - when the specification is blank - registers an offense and corrects - with rubygems_mfa_required: true + dig over a variable as caller + when using multiple `dig` in a method chain + registers and corrects an offense + with multiple arguments + does not register an offense + with single argument + registers an offense and corrects unsuitable use of dig + when using dig with splat operator + does not register an offense + when without a receiver does not register an offense - when the specification has a metadata hash but no rubygems_mfa_required key - registers an offense and corrects - when the specification has an non-hash metadata - registers an offense but does not correct - when metadata is set by key assignment - and `rubygems_mfa_required` is not included - registers an offense - and `rubygems_mfa_required` is included + dig over literal + with multiple arguments + does not register an offense + with single argument + registers an offense and corrects unsuitable use of dig + when using dig with splat operator does not register an offense -RuboCop::Cop::Style::EmptyMethod - when configured with compact style - with an empty class method definition - allows single line method - registers an offense for empty method with arguments - registers an offense for empty method - registers an offense for method with blank line - with a non-empty class method definition - allows multi line method - allows multi line method with comment - allows single line method - relation with Layout/LineLength - when the correction would exceed the configured maximum - reports an offense but does not correct - when that cop is disabled - corrects to long lines - with an empty instance method definition - registers an offense for method with arguments without parens - allows single line method - registers an offense for method with arguments - registers an offense for empty method - registers an offense for method with blank line - registers an offense for method with closing paren on following line - with a non-empty instance method definition - allows single line method - allows multi line method - allows multi line method with comment - when configured with expanded style - with an empty instance method definition - allows multi line method with blank line - registers an offense for single line method - allows multi line method - with a non-empty instance method definition - allows multi line method - allows multi line method with a comment - allows single line method - with an empty class method definition - allows multi line method with a blank line - registers an offense for single line method - allows empty multi line method - when method is nested in class scope - registers an offense for single line method - with a non-empty class method definition - allows multi line method with comment - allows single line method - allows multi line method - relation with Layout/LineLength - still corrects even if the method is longer than the configured Max +RuboCop::Cop::Layout::IndentationStyle + when EnforcedStyle is spaces + accepts a line which begins with tab in a string + accepts a line which begins with tab in a multiline heredoc + accepts a line with a tab other than indentation + registers and corrects an offense for a line indented with tab + registers and corrects an offense for a line indented with mixed whitespaces + accepts a line with tab in a string + registers offenses before __END__ but not after + accepts a line which begins with tab in a heredoc + registers and corrects an offense for a line indented with multiple tabs + accepts a line with a tab between string literals + registers and corrects an offense for a line with tab in a string indented with tab + custom indentation width + uses the configured number of spaces to replace a tab + when EnforcedStyle is tabs + accepts a line with tab in a string + registers an offense for a line indented with mixed whitespace + registers offenses before __END__ but not after + registers and corrects an offense for a line indented with space + accepts a line which begins with tab in a string + accepts a line which begins with tab in a heredoc + accepts a line a tab other than indentation + accepts a line which begins with tab in a multiline heredoc + accepts a line with tabs between string literals + registers and corrects an offense for a line indented with multiple spaces + registers and corrects an offense for a line with tab in a string indented with space + registers and corrects an offense for a line indented with fractional number ofindentation groups by rounding down + custom indentation width + uses the configured number of spaces to replace with a tab -RuboCop::Cop::Style::ColonMethodCall - does not register an offense for constant access - does not register an offense for Java static types - does not register an offense when for constructor methods - registers an offense for class method call - does not register an offense for op methods - does not register an offense for Java package namespaces - does not register an offense for nested class - registers an offense for instance method call - registers an offense for instance method call with arg - registers an offense for class method call with arg +RuboCop::Cop::Style::Proc + registers an offense for ::Proc.new + accepts the Proc.new call without block + accepts the ::Proc.new call without block + registers an offense for a Proc.new call + Ruby 2.7 + registers an offense for a Proc.new call -RuboCop::Cop::Style::EmptyElse - when `AllowComments: true` - given an if-statement - with not comment and empty else-clause +RuboCop::Cop::Lint::EmptyClass + registers an offense for empty object metaclass + registers an offense for empty class metaclass + does not register an offense when metaclass is not empty + does not register an offense when empty has a parent + does not register an offense when class is not empty + registers an offense when empty metaclass contains only comments + registers an offense for empty class + when AllowComments is true + does not register an offense when empty metaclass contains only comments + does not register an offense when empty class contains only comments + +RuboCop::Cop::Lint::UnusedBlockArgument + when IgnoreEmptyBlocks config parameter is set + registers an offense for a non-empty block with multiple unused args + registers an offense for a non-empty block with an unused parameter + accepts an empty block with a single unused parameter + accepts an empty block with multiple unused parameters + inspection + in a method calling `binding` without arguments + accepts all arguments + inside a method definition + registers offenses + when a block takes single argument + and the method call is `define_method` registers an offense - with comment and nil else-clause - doesn't register an offense - with comment and empty else-clause - doesn't register an offense - with not comment and nil else-clause + and the argument is unused + registers an offense and suggests omitting that + when an optional keyword argument is unused + when the method call is `define_method` registers an offense - given an unless-statement - with comment and nil else-clause - doesn't register an offense - with not comment and empty else-clause + when AllowUnusedKeywordArguments set + does not care + when the method call is not `define_method` registers an offense - with comment and empty else-clause - doesn't register an offense - with not comment and nil else-clause + when AllowUnusedKeywordArguments set + does not care + when a lambda block takes arguments + and an argument is unused registers an offense - given a case statement - with not comment and empty else-clause + and all the arguments are unused + registers offenses and suggests using a proc + with an empty block + when not configured to ignore empty blocks registers an offense - with comment and empty else-clause - doesn't register an offense - with not comment and nil else-clause + when configured to ignore empty blocks + does not register an offense + when an underscore-prefixed block argument is not used + accepts + in a method calling `binding` with arguments + when a method argument is unused registers an offense - with comment and nil else-clause - doesn't register an offense - with nested if and case statement - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is if - does autocorrection - MissingElse is case - does not autocorrect - MissingElse is disabled - does autocorrection - configured to warn on empty else and nil in else - given a case statement - with no else-clause - doesn't register an offense - with a completely empty else-clause - behaves like autocorrect - MissingElse is disabled - does autocorrection - MissingElse is case - does not autocorrect - MissingElse is if - does autocorrection - MissingElse is both - does not autocorrect - with an else-clause containing only the literal nil - behaves like autocorrect - MissingElse is case - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is if - does autocorrection - with an else-clause with side-effects - doesn't register an offense - given an if-statement - with a completely empty else-clause - behaves like autocorrect - MissingElse is case - does autocorrection - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is if - does not autocorrect - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil - with multiple elsifs - behaves like autocorrect - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is case - does autocorrection - with one elsif - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is case - does autocorrection - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - with no else-clause - doesn't register an offense - given an unless-statement - with an else-clause with side-effects - doesn't register an offense - with no else-clause - doesn't register an offense - with a completely empty else-clause - behaves like autocorrect - MissingElse is case - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is if - does not autocorrect - with an else-clause containing only the literal nil - behaves like autocorrect - MissingElse is case - does autocorrection - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - configured to warn on nil in else - given an unless-statement - with a completely empty else-clause - doesn't register an offense - with an else-clause containing only the literal nil - behaves like autocorrect - MissingElse is disabled - does autocorrection - MissingElse is if - does not autocorrect - MissingElse is both - does not autocorrect - MissingElse is case - does autocorrection - with no else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - given an if-statement - with no else-clause - doesn't register an offense - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil using semicolons - with multiple elsifs - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is if - does not autocorrect - MissingElse is case - does autocorrection - with one elsif - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is case - does autocorrection - with an else-clause containing only the literal nil - when the result is assigned to a variable - behaves like autocorrect - MissingElse is if - does not autocorrect - MissingElse is case - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is disabled - does autocorrection - when standalone - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is case - does autocorrection - given a case statement - with a completely empty else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with no else-clause - doesn't register an offense - with an else-clause containing only the literal nil - when the result is assigned to a variable - behaves like autocorrect - MissingElse is if - does autocorrection - MissingElse is case - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - using semicolons - behaves like autocorrect - MissingElse is if - does autocorrection - MissingElse is disabled - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is case - does not autocorrect - configured to warn on empty else - given a case statement - with no else-clause - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense - with a completely empty else-clause - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is disabled - does autocorrection - MissingElse is case - does not autocorrect - MissingElse is if - does autocorrection - given an if-statement - with an empty comment - does not autocorrect - with a completely empty else-clause - using semicolons - behaves like autocorrect - MissingElse is case - does autocorrection - MissingElse is both - does not autocorrect - MissingElse is if - does not autocorrect - MissingElse is disabled - does autocorrection - not using semicolons - behaves like autocorrect - MissingElse is both - does not autocorrect - MissingElse is case - does autocorrection - MissingElse is disabled - does autocorrection - MissingElse is if - does not autocorrect - with an else-clause containing only the literal nil - doesn't register an offense - with an else-clause with side-effects - doesn't register an offense - with no else-clause - doesn't register an offense - in an if-statement - behaves like autocorrect - MissingElse is case - does autocorrection - MissingElse is disabled - does autocorrection - MissingElse is if - does not autocorrect - MissingElse is both - does not autocorrect - given an unless-statement - with an else-clause with side-effects - doesn't register an offense - with a completely empty else-clause - behaves like autocorrect - MissingElse is if - does not autocorrect - MissingElse is both - does not autocorrect - MissingElse is case - does autocorrection - MissingElse is disabled - does autocorrection - with no else-clause - doesn't register an offense - with an else-clause containing only the literal nil - doesn't register an offense + when a block takes multiple arguments + and all the arguments are unused + registers offenses and suggests omitting them + and unused arguments span multiple lines + registers offenses and suggests omitting them + and an argument with default value is unused + registers an offense and preserves default value + and all arguments are used + accepts + and an argument is unused + registers an offense + and arguments are swap-assigned + accepts + and one argument is assigned to another, whilst other's value is not used + registers an offense + and a splat argument is unused + registers an offense and preserves splat + when a block have a block local variable + and the variable is unused + registers an offense + and the variable is used + does not register offense + when a method argument is not used + does not care + when a variable is not used + does not care -RuboCop::Cop::Lint::EmptyInterpolation - registers an offense and corrects #{ } in interpolation - accepts non-empty interpolation - finds interpolations in string-like contexts - registers an offense and corrects #{} in interpolation +RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters + accepts execute-string literals + accepts other percent literals + for W type and ["!", "!"] delimiters + accepts newlines and additional following alignment spaces + accepts multi-line literals within a method + accepts literals with escaped spaces + accepts spaces between entries + registers an offense for unnecessary spaces + accepts multi-line literals + registers an offense for spaces after first delimiter + accepts literals without additional spaces + registers an offense for spaces before final delimiter + registers an offense for literals with escaped and other spaces + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + for i type and ["!", "!"] delimiters + registers an offense for unnecessary spaces + registers an offense for spaces before final delimiter + registers an offense for literals with escaped and other spaces + accepts newlines and additional following alignment spaces + accepts literals with escaped spaces + accepts spaces between entries + accepts literals without additional spaces + registers an offense for spaces after first delimiter + accepts multi-line literals within a method + accepts multi-line literals + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for I type and ["!", "!"] delimiters + registers an offense for literals with escaped and other spaces + registers an offense for spaces after first delimiter + accepts spaces between entries + accepts multi-line literals within a method + accepts literals without additional spaces + registers an offense for unnecessary spaces + registers an offense for spaces before final delimiter + accepts newlines and additional following alignment spaces + accepts multi-line literals + accepts literals with escaped spaces + with space in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for i type and ["[", "]"] delimiters + accepts literals with escaped spaces + accepts multi-line literals within a method + registers an offense for spaces after first delimiter + accepts multi-line literals + registers an offense for literals with escaped and other spaces + registers an offense for spaces before final delimiter + accepts spaces between entries + accepts literals without additional spaces + registers an offense for unnecessary spaces + accepts newlines and additional following alignment spaces + with newline in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for I type and ["[", "]"] delimiters + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts literals with escaped spaces + registers an offense for spaces before final delimiter + accepts multi-line literals + accepts spaces between entries + registers an offense for spaces after first delimiter + accepts literals without additional spaces + registers an offense for literals with escaped and other spaces + accepts multi-line literals within a method + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for w type and ["(", ")"] delimiters + registers an offense for spaces before final delimiter + accepts spaces between entries + registers an offense for spaces after first delimiter + registers an offense for unnecessary spaces + registers an offense for literals with escaped and other spaces + accepts literals with escaped spaces + accepts multi-line literals within a method + accepts newlines and additional following alignment spaces + accepts literals without additional spaces + accepts multi-line literals + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for I type and ["{", "}"] delimiters + registers an offense for spaces after first delimiter + accepts newlines and additional following alignment spaces + accepts literals without additional spaces + registers an offense for literals with escaped and other spaces + accepts literals with escaped spaces + accepts multi-line literals within a method + registers an offense for spaces before final delimiter + accepts multi-line literals + registers an offense for unnecessary spaces + accepts spaces between entries + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for w type and ["{", "}"] delimiters + accepts literals without additional spaces + accepts literals with escaped spaces + accepts multi-line literals + registers an offense for spaces after first delimiter + accepts spaces between entries + registers an offense for spaces before final delimiter + registers an offense for literals with escaped and other spaces + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts multi-line literals within a method + with spaces in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + for I type and ["(", ")"] delimiters + accepts newlines and additional following alignment spaces + accepts multi-line literals within a method + registers an offense for literals with escaped and other spaces + accepts literals without additional spaces + accepts spaces between entries + registers an offense for spaces after first delimiter + accepts literals with escaped spaces + registers an offense for spaces before final delimiter + accepts multi-line literals + registers an offense for unnecessary spaces + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for x type and ["[", "]"] delimiters + registers an offense for literals with escaped and other spaces + registers an offense for spaces before final delimiter + accepts literals without additional spaces + registers an offense for spaces after first delimiter + accepts spaces between entries + accepts multi-line literals + accepts literals with escaped spaces + accepts multi-line literals within a method + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for W type and ["{", "}"] delimiters + accepts literals without additional spaces + accepts multi-line literals + accepts spaces between entries + registers an offense for literals with escaped and other spaces + accepts literals with escaped spaces + registers an offense for spaces after first delimiter + accepts multi-line literals within a method + registers an offense for unnecessary spaces + registers an offense for spaces before final delimiter + accepts newlines and additional following alignment spaces + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for i type and ["{", "}"] delimiters + accepts spaces between entries + accepts multi-line literals within a method + accepts multi-line literals + accepts newlines and additional following alignment spaces + registers an offense for spaces after first delimiter + registers an offense for unnecessary spaces + registers an offense for spaces before final delimiter + accepts literals without additional spaces + accepts literals with escaped spaces + registers an offense for literals with escaped and other spaces + with space in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for w type and ["!", "!"] delimiters + accepts multi-line literals + registers an offense for unnecessary spaces + accepts literals without additional spaces + accepts spaces between entries + accepts multi-line literals within a method + registers an offense for spaces after first delimiter + accepts newlines and additional following alignment spaces + registers an offense for spaces before final delimiter + registers an offense for literals with escaped and other spaces + accepts literals with escaped spaces + with newline in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for i type and ["(", ")"] delimiters + accepts spaces between entries + accepts literals with escaped spaces + registers an offense for unnecessary spaces + accepts newlines and additional following alignment spaces + accepts literals without additional spaces + registers an offense for spaces after first delimiter + registers an offense for spaces before final delimiter + accepts multi-line literals within a method + registers an offense for literals with escaped and other spaces + accepts multi-line literals + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for W type and ["[", "]"] delimiters + accepts newlines and additional following alignment spaces + accepts literals without additional spaces + registers an offense for unnecessary spaces + accepts spaces between entries + accepts literals with escaped spaces + registers an offense for literals with escaped and other spaces + accepts multi-line literals + registers an offense for spaces before final delimiter + registers an offense for spaces after first delimiter + accepts multi-line literals within a method + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for W type and ["(", ")"] delimiters + accepts newlines and additional following alignment spaces + registers an offense for literals with escaped and other spaces + accepts multi-line literals within a method + registers an offense for spaces before final delimiter + accepts multi-line literals + accepts spaces between entries + accepts literals without additional spaces + accepts literals with escaped spaces + registers an offense for spaces after first delimiter + registers an offense for unnecessary spaces + with spaces in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + for w type and ["[", "]"] delimiters + registers an offense for spaces after first delimiter + registers an offense for spaces before final delimiter + accepts spaces between entries + accepts literals without additional spaces + registers an offense for literals with escaped and other spaces + accepts multi-line literals within a method + accepts newlines and additional following alignment spaces + accepts multi-line literals + registers an offense for unnecessary spaces + accepts literals with escaped spaces + with space in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for x type and ["!", "!"] delimiters + registers an offense for literals with escaped and other spaces + accepts multi-line literals within a method + accepts literals without additional spaces + accepts literals with escaped spaces + registers an offense for spaces after first delimiter + accepts multi-line literals + registers an offense for spaces before final delimiter + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts spaces between entries + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + for x type and ["{", "}"] delimiters + accepts multi-line literals within a method + registers an offense for spaces before final delimiter + accepts newlines and additional following alignment spaces + registers an offense for spaces after first delimiter + accepts literals without additional spaces + accepts spaces between entries + accepts literals with escaped spaces + registers an offense for literals with escaped and other spaces + accepts multi-line literals + registers an offense for unnecessary spaces + with newline in blank percent literals + registers and corrects an offense + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + for x type and ["(", ")"] delimiters + accepts literals without additional spaces + registers an offense for spaces before final delimiter + registers an offense for literals with escaped and other spaces + registers an offense for spaces after first delimiter + registers an offense for unnecessary spaces + accepts spaces between entries + accepts multi-line literals within a method + accepts multi-line literals + accepts newlines and additional following alignment spaces + accepts literals with escaped spaces + with space in blank percent literals + registers and corrects an offense + with spaces in blank percent literals + registers and corrects an offense + with newline in blank percent literals + registers and corrects an offense -RuboCop::Cop::Layout::EmptyLinesAroundBeginBody - registers an offense for ensure body ending - registers an offense for begin body starting in method - registers an offense for begin body ending in method - registers an offense for begin body starting with rescue - accepts begin block without empty line - registers an offense for rescue body ending - registers many offenses with complex begin-end - registers an offense for begin body starting with a blank - registers an offense for begin body ending with a blank - accepts begin block without empty line in a method - registers an offense for else body ending +RuboCop::Cop::Lint::ConstantDefinitionInBlock + does not register an offense for a constant with an explicit self scope followed by another statement + does not register an offense for a constant with an explicit top-level scope followed by another statement + does not register an offense for a constant with an explicit top-level scope + does not register an offense for a top-level module + does not register an offense for a top-level module followed by another statement + registers an offense for a constant defined within a block followed by another statement + registers an offense for a class defined within a block + registers an offense for a class defined within a block followed by another statement + registers an offense for a module defined within a block + registers an offense for a constant defined within a block + does not register an offense for a top-level constant + does not register an offense for a top-level class followed by another statement + does not register an offense for a top-level constant followed by another statement + does not register an offense for a top-level class + does not register an offense for a constant with an explicit self scope + registers an offense for a module defined within a block followed by another statement + when `AllowedMethods: []` + registers an offense for a class defined within a block of `enums` method + registers an offense for a module defined within a block of `enums` method + registers an offense for a casign used within a block of `enums` method + when `AllowedMethods: [enums]` + does not register an offense for a casign used within a block of `enums` method + does not register an offense for a module defined within a block of `enums` method + does not register an offense for a class defined within a block of `enums` method -RuboCop::Cop::Lint::EachWithObjectArgument - accepts a variable argument - registers an offense for fixnum argument - accepts two arguments - registers an offense for bignum argument - accepts a string argument - registers an offense for float argument - when using safe navigation operator - registers an offense for fixnum argument +RuboCop::Cop::Style::GlobalStdStream + does not register an offense when assigning other const to std stream gvar + does not register an offense when using non std stream const + does not register an offense when assigning std stream const to std stream gvar + registers an offense and corrects when using std stream as const -RuboCop::Cop::Style::RedundantPercentQ - accepts %q at the beginning of a section of a double quoted string with interpolation - accepts %Q at the beginning of a section of a double quoted string with interpolation - accepts %Q at the beginning of a double quoted string with interpolation - accepts a heredoc string that contains %q - accepts %q at the beginning of a double quoted string with interpolation - accepts %q containing string interpolation - with %Q strings - autocorrects for strings that are concatenated with backslash - accepts regular expressions starting with %Q - accepts a string with single quotes and double quotes - registers an offense for static string without quotes - accepts a dynamic %Q string with double quotes - accepts a string with double quotes and an escaped special character - accepts a string with double quotes and an escaped normal character - registers an offense for static string with only double quotes - registers an offense for dynamic string without quotes - with %q strings - accepts a string with single quotes and double quotes - accepts a string with escaped non-backslash characters - registers an offense for no quotes - registers an offense for a string containing escaped backslashes - registers an offense for only single quotes - accepts a string with escaped backslash and non-backslash characters - accepts regular expressions starting with %q - autocorrects for strings that are concatenated with backslash - registers an offense for only double quotes +RuboCop::Cop::Layout::BeginEndAlignment + registers an offense for mismatched begin end and autocorrects + accepts matching begin ... end + accepts matching puts 1; begin ... end + when EnforcedStyleAlignWith is start_of_line + registers an offense for mismatched begin end and autocorrects + registers an offense for mismatched var << begin end and autocorrects + accepts matching var = begin ... end + accepts matching puts 1; begin ... end -RuboCop::Cop::Style::StaticClass - does not register an offense when class has instance method - does not register an offense when class includes/prepends a module - registers an offense when class extends a module - does not register an offense when class has a parent - does not register an offense when class is empty - does not register an offense when class has macro-like method - does not register an offense for modules - registers an offense when class has assignments along with class methods - registers an offense when class has only class method - does not register an offense when class has `class << self` with macro calls - registers an offense when class has `class << self` with class methods +RuboCop::Cop::Layout::FirstMethodParameterLineBreak + registers an offense and corrects params listed on the first line + registers an offense and corrects params on first line of singleton method + registers an offense and corrects params with default values + accepts methods without params + accepts params without parens + accepts params listed on a single line + accepts single-line methods -RuboCop::Cop::Lint::DuplicateHashKey - behaves like duplicated non literal key - does not register an offense for duplicated `{ some_method_call => :sym }` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `some_method_call` hash keys - behaves like duplicated literal key - registers an offense for duplicated `(false <=> true)` hash keys - behaves like duplicated literal key - registers an offense for duplicated `[1, 2, 3]` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `[some_method_call]` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `(x or false)` hash keys - behaves like duplicated literal key - registers an offense for duplicated `(false or true)` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `some_method_call(x, y)` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `(x && false)` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `/.#{some_method_call}/` hash keys - behaves like duplicated literal key - registers an offense for duplicated `(1)` hash keys - target ruby version >= 2.6 - behaves like duplicated literal key - registers an offense for duplicated `(42..)` hash keys - when there is a duplicated key in the hash literal - registers an offense - behaves like duplicated literal key - registers an offense for duplicated `'str'` hash keys - behaves like duplicated literal key - registers an offense for duplicated `nil` hash keys - behaves like duplicated literal key - registers an offense for duplicated `{ a: 1, b: 2 }` hash keys - behaves like duplicated literal key - registers an offense for duplicated `false` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `"#{some_method_call}"` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `(x == false)` hash keys - behaves like duplicated literal key - registers an offense for duplicated `{ :a => 1, :b => 2 }` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `{ :sym => some_method_call }` hash keys - behaves like duplicated literal key - registers an offense for duplicated `/./` hash keys - behaves like duplicated literal key - registers an offense for duplicated `%r{abx}ixo` hash keys - behaves like duplicated literal key - registers an offense for duplicated `(false && true)` hash keys - behaves like duplicated non literal key - does not register an offense for duplicated `%r{abx#{foo}}ixo` hash keys - behaves like duplicated literal key - registers an offense for duplicated `"#{2}"` hash keys - When there is no duplicated key in the hash - does not register an offense - behaves like duplicated literal key - registers an offense for duplicated `!true` hash keys - when there are two duplicated keys in a hash - registers two offenses - behaves like duplicated literal key - registers an offense for duplicated `1.0` hash keys - When a key is duplicated three times in a hash literal - registers two offenses - behaves like duplicated literal key - registers an offense for duplicated `1` hash keys +RuboCop::Cop::AnnotationComment + #annotation? + when the keyword is not capitalized properly + is expected to equal true + when the keyword is multiple words + is expected to equal true + when it includes a keyword + is expected to be falsey + when given a keyword followed by a space + is expected to equal true + when given as the first word of a sentence + is expected to be falsey + when annotated with a non keyword + is expected to be falsey + when given a keyword followed by a colon + is expected to equal true + #correct? + when there is duplication in the keywords + when the shorter keyword is given first + behaves like correct + is expected to be truthy + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + when the longer keyword is given first + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + when no colon is required + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + when a colon is required + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like incorrect + is expected to be falsey + behaves like correct + is expected to be truthy + behaves like incorrect + is expected to be falsey -RuboCop::Cop::Style::MixinUsage - does not register an offense when using inside nested module - include - does not register an offense when using inside block and `if` condition is after `include` - registers an offense when using outside class (used above) - does not register an offense when using `include` in method definition inside module - does not register an offense when using outside class - registers an offense when using outside class (used below) - registers an offense when using `include` in method definition outside class or module - doesn't register an offense when `include` call is a method argument - does not register an offense when using inside block - registers an offense when using only `include` statement - does not register an offense when using inside class - does not register an offense when using `include` in method definition inside class - Nested module - registers an offense when using outside class - Multiple definition classes in one - does not register an offense when using inside class - prepend - does not register an offense when using inside class - registers an offense when using outside class - extend - registers an offense when using outside class - does not register an offense when using inside class +RuboCop::Cop::Lint::UnreachableLoop + does not register an offense when using `return do_something(value) || next` in a loop + does not register an offense when branch includes continue statement preceding break statement + registers an offense when using `return do_something(value) || break` in a loop + handles inner loops + does not register an offense when using `return do_something(value) || redo` in a loop + with preceding continue statements + does not register an offense when using `case-when-else` with all break branches + does not register an offense when using `break` + does not register an offense when using `if-else` with all break branches + Ruby 2.7 + registers an offense when using `return do_something(value) || break` in a loop + with AllowedPatterns + with a ignored method call + does not register an offense + with a non ignored method call + registers an offense + Ruby 2.7 + registers an offense + without preceding continue statements + registers an offense when using `if-else` with all break branches + does not register an offense when using `case-when-else` and not all branches are breaking + registers an offense when using `break` + does not register an offense when using `case` without `else` + registers an offense when using `case-when-else` with all break branches + does not register an offense when using `if-elsif-else` and not all branches are breaking + does not register an offense when using `if` without `else` + with an enumerator method + in the middle of a method chain + does not register an offense + not chained + registers an offense + as the last item in a method chain + registers an offense -RuboCop::Cop::Layout::EmptyLinesAroundMethodBody - is not fooled by single line methods - accepts method body starting with a line with spaces - registers an offense for class method body starting with a blank - registers an offense for method body ending with a blank - registers an offense for class method body ending with a blank - registers an offense for method body starting with a blank +RuboCop::Cop::Style::ParallelAssignment + corrects parallel assignment in while statements + corrects when the expression uses a modifier until statement + corrects when assigning from multiple methods with blocks + registers an offense when right hand side has maps with blocks + registers an offense when assignments must be reordered to preserve meaning + corrects when the expression uses a modifier while statement + registers an offense when the right side has methods with/without blocks + registers an offense when left hand side ends with an implicit variable + allows expanding an assigned var + corrects when using parallel assignment in singleton method + registers an offense when the right side has mulitiple arrays + corrects when assigning to method returns + allows more left variables than right variables + corrects parallel assignment inside rescue statements within method definitions + corrects when using constants + registers an offense when assigning to same variables in same order + registers an offense when assigning to namespaced constants + allows more right variables than left variables + corrects when using single indentation + corrects when the expression uses a modifier rescue statement inside of a method + corrects when the expression uses a modifier if statement + registers an offense when the right side has mixed expressions + corrects when the expression uses a modifier unless statement + registers an offense when the right side has constants + registers an offense with indices of different variables + corrects when assignments must be reordered to avoid changing meaning + corrects parallel assignment in if statements + registers an offense when the right side has multiple hashes + corrects when the right variable is a word array + corrects parallel assignment in rescue statements within begin ... rescue + corrects when the expression uses a modifier if statement inside a method + corrects when using nested indentation + corrects when the right variable is a symbol array + registers an offense with attributes when assignments must be reordered to preserve meaning + registers an offense with indices and attributes when assignments must be reordered to preserve meaning + corrects parallel assignment in unless statements + registers an offense with indices + corrects when the expression uses a modifier rescue statement as the only thing inside of a method + corrects when the expression is missing spaces + corrects when the expression uses a modifier rescue statement + corrects parallel assignment in until statements + corrects when the right variable is an array + registers an offense when right hand side has namespaced constants + corrects when the number of left hand variables matches the number of right hand variables + behaves like allowed + allows assignment of: a, b = *foo + behaves like allowed + allows assignment of: a = *'foo' + behaves like allowed + allows assignment of: a, b = Float::INFINITY + behaves like allowed + allows assignment of: a = a + behaves like allowed + allows assignment of: a, = *'foo' + behaves like allowed + allows assignment of: a, b, c = *node, 1, 2 + behaves like allowed + allows assignment of: ary[0], ary[1], ary[2] = ary[1], ary[2], ary[0] + behaves like allowed + allows assignment of: *a, b = [1, 2, 3] + behaves like allowed + allows assignment of: foo = [1, 2, 3]; a, b, c = foo; + behaves like allowed + allows assignment of: a[0], a[1] = a[1], a[0] + behaves like allowed + allows assignment of: a = 1 + behaves like allowed + allows assignment of: obj.attr1, obj.attr2 = obj.attr2, obj.attr1 + behaves like allowed + allows assignment of: self.a, self.b = b, a + behaves like allowed + allows assignment of: a, b, c = 1, 2, *node + behaves like allowed + allows assignment of: a = 1; b = 2; + behaves like allowed + allows assignment of: obj.attr1, ary[0] = ary[0], obj.attr1 + using custom indentation width + works with nesting + works with rescue + works with guard clauses + works with standard correction + behaves like allowed + allows assignment of: self.a, self.b = self.b, self.a + behaves like allowed + allows assignment of: CONSTANT, = 1, 2 + behaves like allowed + allows assignment of: a, = *foo + behaves like allowed + allows assignment of: a, = a + behaves like allowed + allows assignment of: a, b, c = b, c, a + behaves like allowed + allows assignment of: a, = 1, 2, 3 + behaves like allowed + allows assignment of: a, *b = [1, 2, 3] + behaves like allowed + allows assignment of: a, b = b, a + behaves like allowed + allows assignment of: a, b = (a + b), (a - b) + behaves like allowed + allows assignment of: a, b = foo() + behaves like allowed + allows assignment of: a, b = foo.map { |e| e.id } + behaves like allowed + allows assignment of: begin_token, end_token = CONSTANT + behaves like allowed + allows assignment of: a, = 1 + behaves like allowed + allows assignment of: array = [1, 2, 3]; a, = array; -RuboCop::Cop::Style::BisectedAttrAccessor - registers an offense and corrects when within eigenclass - registers an offense for accessors with the same visibility in different scopes - registers an offense and corrects properly when attr_writer is before attr_reader - registers an offense and corrects when both accessors are in the same visibility scope - registers an offense and corrects when attr and attr_writer exists - does not register an offense when using `attr_accessor` - registers and corrects in a module - does not register an offense when only one accessor of the name exists - registers an offense and corrects when both accessors of the name exists and accessor contains multiple names - registers an offense and corrects when both accessors of the splat exists - registers an offense and corrects when both accessors of the name exists - does not register an offense when accessors are within different visibility scopes - multiple bisected accessors - when all attr names are bisected - registers and replaces with attr_accessor - when some attr names are bisected - registers and retains non-bisected attrs +RuboCop::ConfigRegeneration + #options + when no todo file exists + is expected to eq {:auto_gen_config=>true} + it parses options from the generation comment + is expected to eq {:auto_gen_config=>true, :auto_gen_only_exclude=>true, :auto_gen_timestamp=>false, :exclude_limit=>"100", :offense_counts=>false} + when there is a blank todo file + is expected to eq {:auto_gen_config=>true} + when the todo file is malformed + is expected to eq {:auto_gen_config=>true} -RuboCop::Cop::Lint::ConstantResolution - registers an offense not qualifying a const - registers no offense qualifying a namespace const - registers an offense not qualifying a namespace const - registers no offense when qualifying a const - with Ignore set - registers no offense when an unqualified namespace const - registers an offense not qualifying another const - registers no offense when qualifying a const - registers an with a namespace const - registers no offense qualifying a namespace const - registers no offense with an unqualified const - module & class definitions - does not register offense - with Only set - registers an offense with an unqualified const - registers an offense when an unqualified namespace const - registers no offense when qualifying a const - registers no offense qualifying a namespace const - registers no offense not qualifying another const - registers no with a namespace const +RuboCop::Cop::Lint::LambdaWithoutLiteralBlock + registers and corrects an offense when using lambda with `&Proc.new {}` block argument + registers and corrects an offense when using lambda with a proc variable block argument + does not register an offense when using lambda with a symbol proc + registers and corrects an offense when using lambda with `&proc {}` block argument + does not register an offense when using lambda with a literal block + does not register an offense when using `lambda.call` RuboCop::Runner how formatter is invoked + invocation order + is called in the proper sequence #finished - when RuboCop is interrupted by user - sends only processed file paths when RuboCop finished inspecting all files normally sends all file paths the passed files paths is frozen - invocation order - is called in the proper sequence + when RuboCop is interrupted by user + sends only processed file paths + #file_finished + sends an array of detected offenses for the file + sends a file path + the passed path + is frozen #file_started sends file specific information hash sends a file path @@ -6650,7366 +5545,5559 @@ sends all file paths the passed files paths is frozen - #file_finished - sends a file path - sends an array of detected offenses for the file - the passed path - is frozen -RuboCop::Cop::Bundler::GemComment - when investigating Gemfiles - and the file is empty - does not register any offenses - and the file contains source and group - does not register any offenses - when the "OnlyFor" option is set - including one or more option names but not "version_specifiers" - when a gem is uncommented and has one of the specified options - registers an offense - when a gem is uncommented and has a version specifier but none of the specified options - does not register an offense - when a gem is uncommented and contains only options not specified - does not register an offense - including "restrictive_version_specifiers" - when a gem is uncommented and has a frozen version specifier - registers an offense - when a gem is uncommented and has no version specified - does not register an offense - when a gem is commented - does not register an offense - when a gem is uncommented and has only a minimum version specifier - does not register an offense - when a gem is uncommented and has options but no version specifiers - does not register an offense - when a gem is uncommented and has a version specifier along with other options - registers an offense - when a gem is uncommented and has a non-minimum version specifier with a leading space - registers an offense - when a gem is uncommented and has a version specifier without operator - registers an offense - when a gem is uncommented and has a pessimistic version specifier - registers an offense - when a gem is uncommented and has both minimum and non-minimum version specifier - registers an offense - including "version_specifiers" - when a gem is uncommented and has a version specifier along with other options - registers an offense - when a gem is uncommented and has no version specified - does not register an offense - when a gem is commented - does not register an offense - when a gem is uncommented and has options but no version specifiers - does not register an offense - when a gem is uncommented and has multiple version specifiers - registers an offense - when a gem is uncommented and has a version specifier - registers an offense - and a gem has no comment - registers an offense - and the gem is commented - does not register any offenses - and the gem is permitted - does not register any offenses - and the gem is commented on the same line - does not register any offenses - when investigating Ruby files - does not register any offenses +RuboCop::Formatter::TapFormatter + #finished + when no offenses are detected + does not report offenses + when any offenses are detected + reports all detected offenses for all failed files + #file_finished + when no offenses are detected + prints "ok" + when any offenses are detected + prints "not ok" + #report_file + when the source contains multibyte characters + displays text containing the offending source line -RuboCop::Cop::Lint::RefinementImportMethods - Ruby <= 3.0 - does not register an offense when using `prepend` in `refine` block - does not register an offense when using `include` in `refine` block - Ruby >= 3.1 - does not register an offense when using `include` with a receiver in `refine` block - does not register an offense when using `import_methods` in `refine` block - registers an offense when using `include` in `refine` block - registers an offense when using `prepend` in `refine` block - -RuboCop::Cop::Style::TrailingCommaInArrayLiteral - with single line list of values - when EnforcedStyleForMultiline is consistent_comma - accepts empty literal - accepts literal without trailing comma - accepts rescue clause - registers an offense for trailing comma - accepts single element literal without trailing comma - when EnforcedStyleForMultiline is comma - accepts rescue clause - registers an offense for trailing comma - accepts empty literal - accepts literal without trailing comma - accepts single element literal without trailing comma - when EnforcedStyleForMultiline is no_comma - accepts literal without trailing comma - accepts empty literal - accepts single element literal without trailing comma - registers an offense for trailing comma - accepts rescue clause - with multi-line list of values - when EnforcedStyleForMultiline is comma - registers an offense for a literal with two of the values on the same line and a trailing comma - accepts a multiline array with a single item and trailing comma - accepts trailing comma - accepts an empty array being passed as a method argument - accepts a multiline word array - accepts literal with two of the values on the same line - when closing bracket is on same line as last value - accepts literal with no trailing comma - when EnforcedStyleForMultiline is no_comma - accepts HEREDOC with commas - accepts a literal with no trailing comma - registers an offense for trailing comma - autocorrects unwanted comma where HEREDOC has commas - when EnforcedStyleForMultiline is consistent_comma - accepts a multiline array with a single item and trailing comma - accepts a multiline word array - accepts two values on the same line - accepts a multiline array with items on a single line andtrailing comma - registers an offense for literal with two of the values on the same line and no trailing comma - accepts trailing comma - when closing bracket is on same line as last value - registers an offense for no trailing comma - -RuboCop::Cop::Style::ClassVars - does not register an offense for class variable usage - registers an offense for class variable declaration - registers an offense for class variable set on class receiver - registers an offense for class variable set in class - -RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor - constructor does not have disjunctive assignment - accepts - empty constructor - accepts - constructor has disjunctive assignment - LHS is lvar - accepts - LHS is ivar - registers an offense and corrects - constructor calls any method before disjunctive assignment - accepts - constructor calls super before disjunctive assignment - accepts - constructor calls super after assignment - registers an offense and corrects - -RuboCop::Cop::Lint::AmbiguousRange - for an erange - can handle an endless range - registers an offense and corrects when the entire range is parenthesized but contains complex boundaries - does not register an offense if the range is parenthesized - does not register an offense for a constant - registers an offense and corrects when not parenthesized - does not register an offense for a variable - does not register an offense if the range is composed of literals - does not register an offense for `self` - registers an offense and corrects when one side is parenthesized but the other is not - registers an offense and corrects when there are clauses on both sides - can handle a beginningless range - method calls - with RequireParenthesesForMethodChains: true - registers an offense for a chained method call without parens - does not register an offense for a chained method call with parens - behaves like common behavior - does not register an offense for a unary - - requires parens when calling a method on a basic literal - does not register an offense for a unary + - does not register an offense for a non-chained method call - with RequireParenthesesForMethodChains: false - does not register an offense for a chained method call without parens - does not register an offense for a chained method call with parens - behaves like common behavior - does not register an offense for a unary + - does not register an offense for a non-chained method call - does not register an offense for a unary - - requires parens when calling a method on a basic literal - for an irange - registers an offense and corrects when not parenthesized - can handle an endless range - registers an offense and corrects when one side is parenthesized but the other is not - does not register an offense for a constant - registers an offense and corrects when there are clauses on both sides - can handle a beginningless range - does not register an offense for `self` - registers an offense and corrects when the entire range is parenthesized but contains complex boundaries - does not register an offense if the range is parenthesized - does not register an offense for a variable - does not register an offense if the range is composed of literals - method calls - with RequireParenthesesForMethodChains: false - does not register an offense for a chained method call without parens - does not register an offense for a chained method call with parens - behaves like common behavior - requires parens when calling a method on a basic literal - does not register an offense for a unary + - does not register an offense for a non-chained method call - does not register an offense for a unary - - with RequireParenthesesForMethodChains: true - registers an offense for a chained method call without parens - does not register an offense for a chained method call with parens - behaves like common behavior - requires parens when calling a method on a basic literal - does not register an offense for a unary + - does not register an offense for a non-chained method call - does not register an offense for a unary - - -RuboCop::Cop::Bundler::GemVersion - when EnforcedStyle is set to forbidden - does not flag gems included in AllowedGems metadata - does not flag gems without a specified version - flags gems that specify a gem version - when EnforcedStyle is set to required (default) - does not flag gems included in AllowedGems metadata - flags gems that do not specify a version - does not flag gems with a specified version - -RuboCop::Cop::Layout::SpaceAfterNot - registers an offense and corrects multiple spaces after ! - registers an offense and corrects a single space after ! - accepts no space after ! - accepts space after not keyword - registers an offense and corrects space after ! with the negated receiver wrapped in parentheses - -RuboCop::Cop::Style::CommentAnnotation - with default RequireColon configuration (colon + space) - accepts a comment that is obviously a code example - accepts upper case keyword alone - accepts a keyword that is somewhere in a sentence - accepts a keyword that is just the beginning of a sentence - accepts upper case keyword with colon, space and note - missing space after colon - registers an offense and adds space - with multiword keywords - registers an offense for each matching keyword - offenses in consecutive inline comments - registers each of them - missing colon - registers an offense and adds colon - with configured keyword - registers an offense for a missing colon after the word - capitalized keyword - registers an offense and upcases - upper case keyword with space but no note - registers an offense without autocorrection - multiline comment - only registers an offense on the first line - lower case keyword - registers an offense and upcases - upper case keyword with colon but no note - registers an offense without autocorrection - when a keyword is not in the configuration - accepts the word without colon - with RequireColon configuration set to false - accepts upper case keyword with colon, space and note - accepts upper case keyword alone - accepts a keyword that is just the beginning of a sentence - accepts a keyword that is somewhere in a sentence - accepts a comment that is obviously a code example - upper case keyword with colon but no note - registers an offense without autocorrection - with colon - registers an offense and removes colon - when a keyword is not in the configuration - accepts the word with colon - with configured keyword - registers an offense for containing a colon after the word - offenses in consecutive inline comments - registers each of them - upper case keyword with space but no note - registers an offense without autocorrection - lower case keyword - registers an offense and upcases - multiline comment - only registers an offense on the first line - -RuboCop::Cop::Style::StringMethods - registers an offense - when using safe navigation operator - registers an offense - -RuboCop::Cop::Lint::UriEscapeUnescape - registers an offense when using `URI.unescape(enc_uri)` - registers an offense when using `::URI.unescape(enc_uri)` - registers an offense when using `URI.encode('http://example.com')` - registers an offense when using `URI.escape('http://example.com')` - registers an offense when using `::URI.escape('http://example.com')` - registers an offense when using `URI.decode(enc_uri)` - registers an offense when using `URI.escape('@?@!', '!?')` - registers an offense when using `::URI.decode(enc_uri)` - registers an offense when using `::URI.encode('http://example.com)` - -RuboCop::Formatter::FileListFormatter - #file_finished - displays parsable text - -RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout - ignores defs without params - ignores single-line defs - ignores implicit defs - symmetrical style - opening brace on same line as first element - allows closing brace on same line as last multiline element - detects closing brace on different line from last element - autocorrects closing brace on different line from last element - allows closing brace on same line as last element - opening brace on separate line from first element - allows closing brace on separate line from last element - allows closing brace on separate line from last multiline element - detects closing brace on same line as last element - same_line style - opening brace on same line as first element - autocorrects closing brace on different line as last element - allows closing brace on same line as multi-line element - allows closing brace on same line from last element - detects closing brace on different line from multiline element - opening brace on separate line from first element - allows closing brace on same line as last multiline element - allows closing brace on same line as last element - detects closing brace on different line from last element - heredoc - ignores heredocs that could share a last line - detects heredoc structures that are safe to add to - new_line style - opening brace on same line as first element - allows closing brace on different line from last element - allows closing brace on different line from multi-line element - detects closing brace on same line as last multiline element - autocorrects closing brace on same line as last element - opening brace on separate line from first element - allows closing brace on separate line from last element - allows closing brace on separate line from last multiline element - detects closing brace on same line as last element - -RuboCop::Formatter::PacmanFormatter - #step - character is Pacman - removes the first • and puts a ᗧ - character is ghost - removes the first • and puts a ghosts - character is normal dot - removes the first • and puts a . - character is a Pacdot - leaves the progress_line as it is - #update_progress_line - when total_files less than columns in the terminal - updates the progress_line properly - when total_files is greater than columns in the terminal - updates the progress_line properly - when need to change the line - updates the progress_line properly - #next_step - when a offense is detected in a file - calls the step function with a dot - when no offenses are detected - calls the step function with a dot - -RuboCop::Cop::Style::IfInsideElse - ignores if inside unless - isn't offended by if..elsif..else - ignores ternary inside if..else - catches a modifier if nested inside an else after elsif - handles a nested `if...then...else...end` - handles a nested `if...then...elsif...else...end` - ignores unless inside else - catches an if node nested inside an else - ignores nested ternary expressions - isn't offended if there is a statement preceding the if node - handles a nested `if...then...end` - isn't offended if there is a statement following the if node - catches an if..elsif..else nested inside an else - handles a nested `if...then...elsif...end` - catches an if..else nested inside an else - handles a nested multiline `if...then...elsif...else...end` - catches an `if..else` nested inside an `else` and nested inside `if` branch code is empty - when AllowIfModifier is true - accepts a modifier if nested inside an else - when AllowIfModifier is false - catches a modifier if nested inside an else - -RuboCop::TargetFinder - #target_files_in_dir - does not pick directories - picks files with extension .rb - does not pick files specified to be excluded in config - picks ruby executable files with no extension - does not pick files with no extension and no ruby shebang - picks files specified to be included in config - w/ --fail-fast option - works with the expected number of .rb files - when an exception is raised while reading file - and debug mode is enabled - outputs error message - and debug mode is disabled - outputs nothing - #find(..., :only_recognized_file_types) - returns absolute paths - does not find hidden files - when same paths are passed - does not return duplicated file paths - when some non-known Ruby files are specified in the configuration Include and they are explicitly passed as arguments - includes them - when a hidden directory path is passed - finds files under the specified directory - when no argument is passed - finds files under the current directory - when some non-known Ruby files are specified in the configuration Include and they are not explicitly passed as arguments - includes them - when a directory path is passed - finds files under the specified directory - when a hidden directory path is passed - finds files under the specified directory - when files with a ruby extension are passed - picks all the ruby files - when local AllCops/Include lists two patterns - picks two files - when a subdirectory AllCops/Include only lists one pattern - picks two files - when a non-ruby file is passed - doesn't pick the file - when files with ruby interpreters are passed - picks all the ruby files - when some paths are specified in the configuration Exclude and they are explicitly passed as arguments - normally - does not exclude them - when it's forced to adhere file exclusion configuration - excludes them - when input is passed on stdin - includes the file - when a pattern is passed - finds files which match the pattern - when a file with a ruby filename is passed - picks all the ruby files - #find_files - can exclude symlinks as well as directories - works also if a folder is named "**" - does not search excluded top level directories - prevents infinite loops when traversing symlinks - resolves symlinks when looking for excluded directories - works also if a folder is named "{}" - works also if a folder is named "," - #find(..., :all_file_types) - does not find hidden files - returns absolute paths - when some paths are specified in the configuration Exclude and they are explicitly passed as arguments - when it's forced to adhere file exclusion configuration - excludes them - normally - does not exclude them - when input is passed on stdin - includes the file - when some non-known Ruby files are specified in the configuration Include and they are explicitly passed as arguments - includes them - when a hidden directory path is passed - finds files under the specified directory - when a file with a ruby filename is passed - picks all the ruby files - when a pattern is passed - finds files which match the pattern - when a directory path is passed - finds files under the specified directory - when files with ruby interpreters are passed - picks all the ruby files - when some non-known Ruby files are specified in the configuration Include and they are not explicitly passed as arguments - includes them - when same paths are passed - does not return duplicated file paths - when files with a ruby extension are passed - picks all the ruby files - when local AllCops/Include lists two patterns - picks all the ruby files - when a subdirectory AllCops/Include only lists one pattern - picks all the ruby files - when a non-ruby file is passed - picks the file - when no argument is passed - finds files under the current directory - -RuboCop::Cop::Style::TrailingBodyOnClass - accepts class inheritance - registers an offense when body trails after class definition - accepts regular class - registers offense with multi-line class - autocorrects with comment after body - when class is not on first line of processed_source - autocorrect offense - -RuboCop::StringInterpreter - .interpret - handles extended unicode - handles unicode - handles octal - handles hex - behaves like simple escape - handles \\b - behaves like simple escape - handles \\f - behaves like simple escape - handles \\n - behaves like simple escape - handles \\a - behaves like simple escape - handles \\r - behaves like simple escape - handles \\s - behaves like simple escape - handles \\v - behaves like simple escape - handles \\e - behaves like simple escape - handles \\t - -RuboCop::Cop::Style::FileRead - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r') - registers an offense for and corrects `File.open(filename, 'r').read` - registers an offense for and corrects the `File.open` with multiline read block (mode 'rt') - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'rb') - registers an offense for and corrects the `File.open` with inline read block (mode 'r+t') - does not register an offense when not reading from the block variable - registers an offense for and corrects the `File.open` with inline read block (mode 'r+') - registers an offense for and corrects the `File.open` with multiline read block (mode 'r+') - registers an offense for and corrects `File.open(filename, 'r+b').read` - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+t') - registers an offense for and corrects the `File.open` with multiline read block (implicit text mode) - registers an offense for and corrects `File.open(filename, 'r+t').read` - registers an offense for and corrects the `File.open` with inline read block (implicit text mode) - registers an offense for and corrects the `File.open` with inline read block (mode 'rt') - registers an offense for and corrects `File.open(filename, 'rb').read` - registers an offense for and corrects `File.open(filename).read` - registers an offense for and corrects `File.open(filename, 'r+').read` - registers an offense for and corrects `::File.open(filename).read` - registers an offense for and corrects the `File.open` with inline read block (mode 'r') - registers an offense for and corrects the `File.open` with multiline read block (mode 'r+t') - registers an offense for and corrects the `File.open` with inline read block (mode 'rb') - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'rt') - registers an offense for and corrects the `File.open` with symbolic read proc (implicit text mode) - registers an offense for and corrects the `File.open` with inline read block (mode 'r+b') - registers an offense for and corrects `File.open(filename, 'rt').read` - registers an offense for and corrects the `File.open` with multiline read block (mode 'r') - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+') - registers an offense for and corrects the `File.open` with symbolic read proc (mode 'r+b') - registers an offense for and corrects the `File.open` with multiline read block (mode 'r+b') - registers an offense for and corrects the `File.open` with multiline read block (mode 'rb') - -RuboCop::Cop::Style::StringChars - does not register an offense when using `chars` - registers and corrects an offense when using `split("")` - registers and corrects an offense when using `split('')` - registers and corrects an offense when using `split` without parentheses - does not register an offense when using `split` - does not register an offense when using `split(/ /)` - registers and corrects an offense when using `split(//)` - -RuboCop::Cop::Style::SingleLineMethods - autocorrects def with semicolon after method name - does not crash on an method with a capitalized name - autocorrects def with argument and no parentheses - autocorrects def with semicolon before end - autocorrects def with argument in parentheses - autocorrects defs with parentheses after method name - registers an offense for a single-line method - registers an offense for a single-line method and method body is enclosed in parentheses - accepts a multi-line method - when `Style/EndlessMethod` is disabled - corrects to an normal method - endless methods - does not register an offense - when `Style/EndlessMethod` is enabled - with `allow_always` style - behaves like convert to endless method - corrects to an endless class method definition when using <= - corrects to an endless class method definition when using != - does not to an endless class method definition when using `break` - corrects to an endless class method definition when using < - does not to an endless class method definition when using `next` - corrects to an endless class method definition when using === - corrects to multiline method definition when defining setter method - corrects to an endless class method definition when using >= - does not to an endless class method definition when using `return` - corrects to an endless method definition when method body is a literal - corrects to an endless class method definition when using > - handles arguments properly - corrects to an endless class method definition when using == - corrects to an endless method definition - corrects to an endless method definition when single line method call without parentheses - corrects to an endless method definition when single line method call with parentheses - retains comments - corrects to a normal method if the method body contains multiple statements - does not add parens if they are already present - corrects to an endless class method definition - with AllowIfMethodIsEmpty: true - does not correct - with AllowIfMethodIsEmpty: false - does not turn a method with no body into an endless method - prior to ruby 3.0 - corrects to a multiline method - with `disallow` style - corrects to an normal method - with `allow_single_line` style - behaves like convert to endless method - corrects to an endless class method definition when using <= - does not to an endless class method definition when using `return` - corrects to an endless class method definition - does not to an endless class method definition when using `next` - corrects to a normal method if the method body contains multiple statements - corrects to an endless class method definition when using >= - does not to an endless class method definition when using `break` - corrects to an endless method definition when method body is a literal - corrects to multiline method definition when defining setter method - corrects to an endless class method definition when using === - retains comments - handles arguments properly - does not add parens if they are already present - corrects to an endless class method definition when using != - corrects to an endless method definition when single line method call with parentheses - corrects to an endless class method definition when using > - corrects to an endless class method definition when using == - corrects to an endless class method definition when using < - corrects to an endless method definition - corrects to an endless method definition when single line method call without parentheses - with AllowIfMethodIsEmpty: false - does not turn a method with no body into an endless method - with AllowIfMethodIsEmpty: true - does not correct - when AllowIfMethodIsEmpty is enabled - accepts a single-line empty method - when AllowIfMethodIsEmpty is disabled - registers an offense for an empty method - -RuboCop::Cop::Style::FormatString - when enforced style is format - does not autocorrect String#% with variable argument and assignment - does not register an offense for numbers - registers an offense for something followed by a hash - does not register an offense for ambiguous cases - works if the first operand contains embedded expressions - registers an offense for something followed by an array - registers an offense for sprintf with 2 arguments - registers an offense for a string followed by something - registers an offense for sprintf - registers an offense for variable argument but does not autocorrect - when enforced style is percent - registers an offense for sprintf - accepts sprintf with 1 argument - registers an offense for format - accepts sprintf without arguments - registers an offense for sprintf with a hash argument - registers an offense for sprintf with 3 arguments - registers an offense for format with a hash argument - accepts format without arguments - registers an offense for format with 3 arguments - registers an offense and corrects when using springf with second argument that uses an operator - accepts String#% - accepts format with 1 argument - when enforced style is sprintf - registers an offense for format - registers an offense for format with 2 arguments - registers an offense for String#% with a hash argument - registers an offense for something followed by an array - registers an offense for variable argument and assignment but does not autocorrect - registers an offense for a string followed by something - works if the first operand contains embedded expressions - does not register an offense for numbers - does not register an offense for ambiguous cases - registers an offense for variable argument but does not autocorrect - -RuboCop::Cop::Lint::SelfAssignment - does not register an offense when using multiple var assignment through method call - registers an offense when using global var self-assignment - does not register an offense when using shorthand-or var assignment - does not register an offense when using multiple var assignment through splat - registers an offense when using shorthand-and var self-assignment - does not register an offense when using multiple var assignment - does not register an offense when using local var assignment - does not register an offense when using class var assignment - does not register an offense when using constant var or-assignment for constant from another scope - does not register an offense when using shorthand-and var assignment - does not register an offense when using instance var assignment - registers an offense when using multiple var self-assignment - registers an offense when using local var self-assignment - does not register an offense when using global var assignment - does not register an offense when using constant var assignment for constant from another scope - registers an offense when using instance var self-assignment - registers an offense when using shorthand-or var self-assignment - registers an offense when using class var self-assignment - registers an offense when using constant var self-assignment - registers an offense when using multiple var self-assignment through array +RuboCop::Cop::Style::Dir + when using `#dirname` and `#realpath` + registers an offense + registers an offense with ::File + when using `#expand_path` and `#dirname` + registers an offense with ::File + registers an offense RuboCop::Cop::Style::CommandLiteral - when EnforcedStyle is set to mixed - a multi-line %x string without backticks - is accepted - a single-line %x string with backticks + when EnforcedStyle is set to backticks + a multi-line ` string without backticks is accepted - when configured to allow inner backticks - registers an offense without autocorrection - a multi-line ` string with backticks - registers an offense without autocorrection + a multi-line %x string without backticks + registers an offense and corrects to backticks a single-line ` string without backticks is accepted a multi-line %x string with backticks is accepted + when configured to allow inner backticks + registers an offense without autocorrection a single-line ` string with backticks registers an offense without autocorrection when configured to allow inner backticks is accepted - a multi-line ` string without backticks - registers an offense and corrects to %x + a single-line %x string with backticks + is accepted + when configured to allow inner backticks + registers an offense without autocorrection a single-line %x string without backticks registers an offense and corrects to backticks - %x commands with other delimiters than parentheses - registers an offense - heredoc commands - is ignored - when EnforcedStyle is set to backticks a multi-line ` string with backticks registers an offense without autocorrection when configured to allow inner backticks is accepted + when EnforcedStyle is set to mixed a multi-line ` string without backticks + registers an offense and corrects to %x + a multi-line %x string with backticks is accepted - a single-line %x string with backticks - is accepted + a single-line ` string with backticks + registers an offense without autocorrection when configured to allow inner backticks - registers an offense without autocorrection - a single-line %x string without backticks - registers an offense and corrects to backticks + is accepted + a multi-line ` string with backticks + registers an offense without autocorrection a single-line ` string without backticks is accepted - a multi-line %x string with backticks + a multi-line %x string without backticks + is accepted + a single-line %x string without backticks + registers an offense and corrects to backticks + a single-line %x string with backticks is accepted when configured to allow inner backticks registers an offense without autocorrection - a multi-line %x string without backticks - registers an offense and corrects to backticks + when EnforcedStyle is set to percent_x a single-line ` string with backticks registers an offense without autocorrection - when configured to allow inner backticks - is accepted - when PercentLiteralDelimiters only has a default - respects the configuration when autocorrecting - when PercentLiteralDelimiters is configured and a default exists - ignores the default when autocorrecting - when EnforcedStyle is set to percent_x - a multi-line ` string without backticks + a single-line ` string without backticks registers an offense and corrects to %x - a single-line %x string with backticks - is accepted a multi-line %x string without backticks is accepted - a single-line %x string without backticks + a multi-line %x string with backticks + is accepted + a single-line %x string with backticks is accepted a multi-line ` string with backticks registers an offense without autocorrection - a multi-line %x string with backticks - is accepted - a single-line ` string without backticks + a multi-line ` string without backticks registers an offense and corrects to %x - a single-line ` string with backticks - registers an offense without autocorrection + a single-line %x string without backticks + is accepted + when PercentLiteralDelimiters only has a default + respects the configuration when autocorrecting + when PercentLiteralDelimiters is configured and a default exists + ignores the default when autocorrecting + heredoc commands + is ignored + %x commands with other delimiters than parentheses + registers an offense when PercentLiteralDelimiters is configured with curly braces respects the configuration when autocorrecting -RuboCop::Cop::Style::Lambda - with enforced `lambda` style - with a multiline lambda literal - without arguments - registers an offense - with arguments - registers an offense - with a single line lambda literal - without argument parens and spaces - registers an offense - without arguments - registers an offense - with arguments - registers an offense - when using safe navigation operator - does not break - with enforced `literal` style - with a single line lambda method call - with arguments - registers an offense - without arguments - registers an offense - with a multiline lambda method call - without arguments - registers an offense - with arguments - registers an offense - with default `line_count_dependent` style - with a multiline do-end lambda literal as a keyword argument - registers an offense - with a multiline lambda literal - without arguments - registers an offense - with arguments - registers an offense - >= Ruby 2.7 - when using numbered parameter - with a single line lambda literal - does not register an offense - with a single line lambda method call - registers an offense - with a multiline lambda method call - does not register an offense - when calling a lambda method without a block - does not register an offense - with a single line lambda literal - does not register an offense - with a multiline lambda literal as an argument - registers an offense - with a multiline do-end lambda as a parenthesized kwarg - registers an offense - unusual lack of spacing - without any spacing - registers an offense - without spacing after arguments - registers an offense - with a multiline lambda literal - with no arguments and no spacing - registers an offense - without parentheses - registers an offense - with empty arguments - registers an offense - with no parentheses and many args - registers an offense - with no arguments and bad spacing - registers an offense - with no parentheses and bad spacing - registers an offense - without spacing before arguments - registers an offense - with a multiline lambda method call - does not register an offense - with a multiline braces lambda literal as a keyword argument - registers an offense - with a single line lambda method call - without arguments - registers an offense - with arguments - registers an offense - -RuboCop::Cop::Lint::UselessMethodDefinition - does not register an offense when `super` arguments differ from method arguments - does not register an offense when method definition contains optional argument - does not register an offense for empty constructor - does not register an offense for constructor containing additional code to `super` - does not register an offense when method definition contains optional keyword argument - does not register an offense for empty class level `initialize` method - does not register an offense when non-constructor contains only comments - registers an offense and corrects for method containing only `super` call - does not register an offense for constructor with only comments - does not register an offense for method containing additional code to `super` +RuboCop::Cop::Layout::EndAlignment + accepts matching puts 1; case ... end + registers an offense for mismatched puts 1; while test end and autocorrects + accepts matching unless ... end + accepts matching class ... end + accepts matching class ... end + registers an offense for mismatched puts 1; class Test end and autocorrects + accepts matching while ... end + registers an offense for mismatched case a when b end and autocorrects + accepts matching case ... end + registers an offense for mismatched module Test end and autocorrects + registers an offense for mismatched puts 1; if test end and autocorrects + accepts matching if ... end + registers an offense for mismatched until test end and autocorrects + accepts matching puts 1; class ... end + registers an offense for mismatched unless test end and autocorrects + registers an offense for mismatched puts 1; case a when b end and autocorrects + registers an offense for mismatched puts 1; class Test end and autocorrects + registers an offense for mismatched while test end and autocorrects + registers an offense for mismatched module Test end and autocorrects + accepts matching puts 1; unless ... end + accepts matching puts 1; if ... end + registers an offense for mismatched puts 1; unless test end and autocorrects + registers an offense for mismatched puts 1; until test end and autocorrects + registers an offense for mismatched if test end and autocorrects + can handle modifier if + accepts matching until ... end + accepts matching puts 1; until ... end + accepts matching puts 1; while ... end + can handle ternary if + accepts matching puts 1; module ... end + accepts matching module ... end + when end is preceded by something else than whitespace + does not register an offense + regarding assignment + when EnforcedStyleAlignWith is keyword + registers an offense for mismatched var = if test end and autocorrects + accepts matching var = until ... end + accepts matching var = while ... end + accepts matching var = case ... end + accepts matching var = if ... end + registers an offense for mismatched var = until test end and autocorrects + registers an offense for mismatched var << until test end and autocorrects + registers an offense for mismatched var = unless test end and autocorrects + accepts matching var = unless ... end + registers an offense for mismatched var = while test end and autocorrects + accepts matching var[0] = case ... end + when EnforcedStyleAlignWith is variable + accepts matching var += if ... end + registers an offense for mismatched var = if test end and autocorrects + registers an offense for mismatched var = until test end and autocorrects + registers an offense for mismatched @var << if test end and autocorrects + registers an offense for mismatched h.k = if test end and autocorrects + registers an offense for mismatched @@var << if test end and autocorrects + accepts matching var = until ... end + accepts matching $var = if ... end + registers an offense for mismatched var = # comment while test end and autocorrects + accepts matching @@var = if ... end + registers an offense for mismatched var = unless test end and autocorrects + accepts matching CNST = if ... end + registers an offense for mismatched h[k] = if test end and autocorrects + accepts matching var = while ... end + registers an offense for mismatched var &&= if test end and autocorrects + accepts matching a, b = if ... end + accepts matching var = if ... end + registers an offense for mismatched var = while test end and autocorrects + registers an offense for mismatched var << if test end and autocorrects + accepts matching var = if ... end + registers an offense for mismatched var = if test end and autocorrects + accepts matching var = until ... end + registers an offense for mismatched var = case a when b end and autocorrects + registers an offense for mismatched CNST << if test end and autocorrects + registers an offense for mismatched $var = if test end and autocorrects + registers an offense for mismatched var << until test end and autocorrects + registers an offense for mismatched CNST = if test end and autocorrects + registers an offense for mismatched var << unless test end and autocorrects + registers an offense for mismatched var ||= if test end and autocorrects + accepts matching var = case ... end + registers an offense for mismatched var << case a when b end and autocorrects + registers an offense for mismatched var = until test end.j and autocorrects + accepts matching var ||= if ... end + accepts matching var << if ... end + registers an offense for mismatched $var << if test end and autocorrects + registers an offense for mismatched var += if test end and autocorrects + accepts matching var = unless ... end + accepts matching var &&= if ... end + registers an offense for mismatched h[k] << if test end and autocorrects + accepts matching h.k = if ... end + accepts matching var = until ... end + registers an offense for mismatched var = unless test end and autocorrects + registers an offense for mismatched a, b = if test end and autocorrects + registers an offense for mismatched var[x] = while test end and autocorrects + registers an offense for mismatched @@var = if test end and autocorrects + registers an offense for mismatched var = until test do_something end and autocorrects + registers an offense for mismatched @var = if test end and autocorrects + accepts matching h[k] = if ... end + accepts matching @var = if ... end + when EnforcedStyleAlignWith is variable + registers an offense for mismatched puts 1; case a when b end and autocorrects + registers an offense for mismatched while test end and autocorrects + registers an offense for mismatched module Test end and autocorrects + accepts matching puts 1; if ... end + registers an offense for mismatched puts 1; module Test end and autocorrects + registers an offense for mismatched puts 1; class Test end and autocorrects + register an offense when using `-` operator method and `end` is not aligned + register an offense when using `+` operator method and `end` is not aligned + accepts matching puts 1; class ... end + registers an offense for mismatched until test end and autocorrects + accepts matching puts 1; unless ... end + registers an offense for mismatched if test end and autocorrects + registers an offense for mismatched class Test end and autocorrects + accepts matching case ... end + registers an offense for mismatched puts 1; if test end and autocorrects + accepts matching puts 1; while ... end + accepts matching puts 1; until ... end + registers an offense for mismatched puts 1; unless test end and autocorrects + accepts matching puts 1; case ... end + registers an offense for mismatched unless test end and autocorrects + accepts matching puts 1; module ... end + accepts matching module ... end + registers an offense for mismatched case a when b end and autocorrects + registers an offense for mismatched puts 1; while test end and autocorrects + accepts matching until ... end + accepts matching if ... end + accepts matching unless ... end + register an offense when using a conditional statement in a method argument and `end` is not aligned + accepts matching while ... end + registers an offense for mismatched puts 1; until test end and autocorrects + accepts matching class ... end + case as argument + when EnforcedStyleAlignWith is variable + registers an offense for mismatched test case a when b end and autocorrects + accepts matching test case ... end + when EnforcedStyleAlignWith is start_of_line + registers an offense for mismatched test case a when b end and autocorrects + accepts matching test case a when b ... end + when EnforcedStyleAlignWith is keyword + accepts matching test case ... end + registers an offense for mismatched test case a when b end and autocorrects + correct + opposite + registers an offense and corrects + when EnforcedStyleAlignWith is start_of_line + registers an offense for mismatched var = unless test end and autocorrects + registers an offense for mismatched var << until test end and autocorrects + accepts matching var = if ... end + registers an offense for mismatched puts 1; class Test end and autocorrects + registers an offense for mismatched puts 1; until test end and autocorrects + accepts matching puts 1; module ... end + accepts matching var = if ... end + accepts matching var = case ... end + registers an offense for mismatched puts 1; module Test end and autocorrects + accepts matching puts 1; if ... end + registers an offense for mismatched var = if test end and autocorrects + registers an offense for mismatched if test end and autocorrects + registers an offense for mismatched var = until test end and autocorrects + registers an offense for mismatched puts 1; if test end and autocorrects + registers an offense for mismatched until test end and autocorrects + registers an offense for mismatched var = if test end and autocorrects + registers an offense for mismatched case a when b end and autocorrects + registers an offense for mismatched module Test end and autocorrects + registers an offense for mismatched var = while test end and autocorrects + accepts matching puts 1; case ... end + accepts matching puts 1; class ... end + registers an offense for mismatched var = case a when b end and autocorrects + accepts matching puts 1; while ... end + registers an offense for mismatched puts 1; while test end and autocorrects + registers an offense for mismatched var << if test end and autocorrects + registers an offense for mismatched puts 1; unless test end and autocorrects + accepts matching var = while ... end + accepts matching var << while ... end + registers an offense for mismatched unless test end and autocorrects + accepts matching var = until ... end + registers an offense for mismatched puts(if test end) and autocorrects + accepts matching var = unless ... end + accepts matching puts 1; unless ... end + registers an offense for mismatched var << case a when b end and autocorrects + accepts matching puts 1; until ... end + registers an offense for mismatched puts 1; case a when b end and autocorrects + registers an offense for mismatched while test end and autocorrects + registers an offense for mismatched var << unless test end and autocorrects + registers an offense for mismatched class Test end and autocorrects + registers an offense for mismatched var << while test end and autocorrects -RuboCop::Formatter::MarkdownFormatter - outputs the cached result in Markdown - outputs the result in Markdown +RuboCop::Cop::Style::DocumentDynamicEvalDefinition + registers an offense when using eval-type method with interpolated string that is not heredoc without comment doc + does not register an offense when using eval-type method without string interpolation + registers an offense when using eval-type method with string interpolation without comment docs + does not register an offense when using eval-type method with string interpolation with comment docs + does not register an offense when using eval-type method with interpolated string that is not heredoc with comment doc + block comment outside heredoc + does not register an offense when using multiple methods + registers an offense if the comment does not match the method + does not register an offense when using inline comments + does not register an offense when using other text + does not register an offense for a matching block comment before the heredoc + does not register an offense for a matching block comment after the heredoc + block comment in heredoc + does not register an offense for a matching block comment + does not register an offense when using other text + does not register an offense when using multiple methods with split comments + does not register an offense when using multiple methods + does not register an offense when using inline comments + does not evaluate comments if there is no interpolation + registers an offense if the comment does not match the method -RuboCop::Cop::Gemspec::DependencyVersion - with `EnforcedStyle: forbidden` - using add_development_dependency - registers an offense when adding development dependency with commit ref specification - registers an offense when adding development dependency by parenthesized call with branch specification - does not register an offense when adding development dependency by parenthesized call without version specification - registers an offense when adding development dependency with branch specification - registers an offense when adding development dependency with version specification - registers an offense when adding development dependency by parenthesized call with version specification - does not register an offense when adding development dependency without version specification - does not register an offense when adding development dependency using git option by parenthesized call without version specification - registers an offense when adding development dependency by parenthesized call with commit ref specification - registers an offense when adding development dependency with tag specification - registers an offense when adding development dependency by parenthesized call with tag specification - does not register an offense when adding development dependency using git option without version specification - with `AllowedGems` - registers an offense when adding dependency without version specification - registers an offense when adding dependency by parenthesized call without version specification - using add_runtime_dependency - does not register an offense when adding runtime dependency using git option without version specification - does not register an offense when adding runtime dependency by parenthesized call without version specification - registers an offense when adding runtime dependency by parenthesized call with tag specification - registers an offense when adding runtime dependency by parenthesized call with commit ref specification - registers an offense when adding runtime dependency by parenthesized call with version specification - registers an offense when adding runtime dependency with tag specification - registers an offense when adding runtime dependency with version specification - registers an offense when adding runtime dependency with commit ref specification - does not register an offense when adding runtime dependency without version specification - registers an offense when adding runtime dependency by parenthesized call with branch specification - registers an offense when adding runtime dependency with branch specification - does not register an offense when adding runtime dependency using git option by parenthesized call without version specification - using add_dependency - registers an offense when adding dependency with version specification - registers an offense when adding dependency with commit ref specification - does not register an offense when adding dependency using git option without version specification - registers an offense when adding dependency by parenthesized call with commit ref specification - registers an offense when adding dependency by parenthesized call with branch specification - registers an offense when adding dependency with tag specification - registers an offense when adding dependency by parenthesized call with tag specification - does not register an offense when adding dependency by parenthesized call without version specification - registers an offense when adding dependency by parenthesized call with version specification - does not register an offense when adding dependency using git option by parenthesized call without version specification - does not register an offense when adding dependency without version specification - registers an offense when adding dependency with branch specification - with `EnforcedStyle: required` - using add_development_dependency - does not register an offense when adding development dependency with commit ref specification - registers an offense when adding development dependency using git option by parenthesized call without version specification - registers an offense when adding development dependency without version specification - does not register an offense when adding development dependency with version specification - does not register an offense when adding development dependency by parenthesized call with branch specification - does not register an offense when adding development dependency by parenthesized call with tag specification - registers an offense when adding development dependency using git option without version specification - does not register an offense when adding development dependency by parenthesized call with version specification - does not register an offense when adding development dependency with tag specification - does not register an offense when adding development dependency with branch specification - registers an offense when adding development dependency by parenthesized call without version specification - does not register an offense when adding development dependency by parenthesized call with commit ref specification - using add_runtime_dependency - registers an offense when adding runtime dependency by parenthesized call without version specification - does not register an offense when adding runtime dependency with tag specification - does not register an offense when adding runtime dependency by parenthesized call with version specification - does not register an offense when adding runtime dependency with version specification - does not register an offense when adding runtime dependency by parenthesized call with tag specification - does not register an offense when adding runtime dependency with commit ref specification - registers an offense when adding runtime dependency using git option by parenthesized call without version specification - does not register an offense when adding runtime dependency by parenthesized call with branch specification - registers an offense when adding runtime dependency without version specification - does not register an offense when adding runtime dependency by parenthesized call with commit ref specification - does not register an offense when adding runtime dependency with branch specification - registers an offense when adding runtime dependency using git option without version specification - with `AllowedGems` - registers an offense when adding dependency without version specification excepts allowed gems - registers an offense when adding dependency by parenthesized call without version specification excepts allowed gems - using add_dependency - registers an offense when adding dependency by parenthesized call without version specification - registers an offense when adding dependency using git option without version specification - does not register an offense when adding dependency by parenthesized call with branch specification - does not register an offense when adding dependency by parenthesized call with tag specification - registers an offense when adding dependency without version specification - does not register an offense when adding dependency with tag specification - does not register an offense when adding dependency by parenthesized call with version specification - does not register an offense when adding dependency with version specification - does not register an offense when adding dependency by parenthesized call with commit ref specification - registers an offense when adding dependency using git option by parenthesized call without version specification - does not register an offense when adding dependency with branch specification - does not register an offense when adding dependency with commit ref specification +RuboCop::Cop::Style::MethodDefParentheses + require_parentheses + accepts def with no args and no parens + reports an offense for def with parameters but no parens + auto-adds required parens for a defs after a passing method + auto-adds required parens to argument lists on multiple lines + auto-adds required parens for a defs + reports an offense for class def with parameters but no parens + reports an offense for correct + opposite + behaves like endless methods + endless methods + accepts parens with `forward-arg` + accepts parens for method calls inside an endless method + accepts parens with args + accepts parens without args + require_no_parentheses + behaves like no parentheses + reports an offense for opposite + correct + requires parens for anonymous block forwarding + accepts def with no args and no parens + auto-removes the parens for defs + accepts a class def with parameters with parens + reports an offense for def with no args and parens + reports an offense for class def with parameters with parens + reports an offense for def with parameters with parens + accepts a def with parameters but no parens + requires parens for forwarding + behaves like endless methods + endless methods + accepts parens for method calls inside an endless method + accepts parens with args + accepts parens without args + accepts parens with `forward-arg` + require_no_parentheses_except_multiline + when args are all on a single line + behaves like no parentheses + accepts def with no args and no parens + accepts a def with parameters but no parens + reports an offense for def with parameters with parens + requires parens for anonymous block forwarding + accepts a class def with parameters with parens + reports an offense for opposite + correct + requires parens for forwarding + auto-removes the parens for defs + reports an offense for def with no args and parens + reports an offense for class def with parameters with parens + behaves like endless methods + endless methods + accepts parens with `forward-arg` + accepts parens for method calls inside an endless method + accepts parens with args + accepts parens without args + when args span multiple lines + reports an offense for correct + opposite + auto-adds required parens to argument lists on multiple lines -RuboCop::Formatter::JUnitFormatter - #file_finished - displays end of parsable text - displays a non-offense element in parsable text - displays an offense for `classname='test_2` in parsable text - displays an offense for `classname='test_1` in parsable text - displays start of parsable text +RuboCop::Cop::Style::RaiseArgs + when enforced style is compact + accepts exception constructor with keyword arguments and message argument + accepts a raise with msg argument + accepts a raise with an exception argument + when used in a ternary expression + registers an offense and autocorrects + with a raise with 2 args and exception object is assigned to a local variable + reports an offense + with a raise with 3 args + reports an offense + with correct + opposite + reports an offense + reports multiple offenses + with a raise with exception instantiation and message arguments + reports an offense + when used in a logical or expression + registers an offense and autocorrects + when used in a logical and expression + registers an offense and autocorrects + with a raise with 2 args + reports an offense + when enforced style is exploded + accepts a raise with 2 args + accepts a raise when exception object is assigned to a local variable + accepts exception constructor with more than 1 argument + accepts a raise with msg argument + ignores a raise with an exception argument + accepts exception constructor with keyword arguments + accepts a raise with splatted arguments + accepts a raise with 3 args + accepts a raise with `new` method without receiver + when exception type is in AllowedCompactTypes + accepts exception constructor with no arguments + with more than one argument + accepts exception constructor + with one argument + accepts exception constructor + with opposite + correct + reports an offense for opposite + correct + reports multiple offenses + when an exception object is assigned to a local variable + autocorrects to exploded style + with a raise with exception object + with one argument + reports an offense + when used in a ternary expression + registers an offense and autocorrects + when used in a logical and expression + registers an offense and autocorrects + with no arguments + reports an offense + when used in a logical or expression + registers an offense and autocorrects -RuboCop::Cop::Naming::MemoizedInstanceVariableName - does not register an offense when or-assignment-based memoization is used outside a method definition - EnforcedStyleForLeadingUnderscores: optional - when or-assignment-based memoization is used - when defined?-based memoization is used - memoized variable matches method name - does not register an offense with a leading `_` for both names - does not register an offense without a leading underscore - does not register an offense with a leading `_` for method name - does not register an offense with a leading underscore - memoized variable matches method name - does not register an offense with a leading `_` for both names - does not register an offense without a leading underscore - does not register an offense with a leading `_` for method name - does not register an offense with a leading underscore - with default EnforcedStyleForLeadingUnderscores => disallowed - when defined?-based memoization is used - registers an offense when memoized variable does not match method name - does not register an offense when some code after assignment - does not register an offense when there is no assignment - registers an offense when memoized variable does not match class method name - does not register an offense when some code before defined - with dynamically defined methods - when a singleton method is defined inside a module callback - when the method matches - does not register an offense - when the method does not match - registers an offense - when a method is defined inside a module callback - when the method does not match - registers an offense - when the method matches - does not register an offense - when the variable name does not match the method name - registers an offense - when the variable name matches the method name - does not register an offense - memoized variable matches method name - does not register an offense when memoized variable matches bang method name - does not register an offense with a leading `_` for both names - does not register an offense when memoized variable matches predicate method name - does not register an offense - does not register an offense when method has leading `_` - non-memoized variable does not match method name - does not register an offense - when or-assignment-based memoization is used - memoized variable after other code does not match method name - registers an offense for a bang method - registers an offense for a predicate method - registers an offense - memoized variable does not match method name during assignment - registers an offense - memoized variable does not match method name for block - registers an offense - with dynamically defined methods - when a method is defined inside a module callback - when the method does not match - registers an offense - when the method matches - does not register an offense - when the variable name does not match the method name - registers an offense - when a singleton method is defined inside a module callback - when the method does not match - registers an offense - when the method matches - does not register an offense - when the variable name matches the method name - does not register an offense - memoized variable matches method name - does not register an offense - does not register an offense when method has leading `_` - does not register an offense with a leading `_` for both names - code follows memoized variable assignment - does not register an offense - memoized variable after other code - does not register an offense - instance variables in initialize methods - does not register an offense - memoized variable matches method name during assignment - does not register an offense - non-memoized variable does not match method name - does not register an offense - memoized variable matches method name for block - does not register an offense - memoized variable matches bang method name - does not register an offense - memoized variable matches predicate method name - does not register an offense - memoized variable does not match class method name - registers an offense - memoized variable does not match method name - registers an offense - EnforcedStyleForLeadingUnderscores: required - when or-assignment-based memoization is used - registers an offense when names match but missing a leading _ - does not register an offense with a leading `_` for both names - registers an offense when it has leading `_` but names do not match - with dynamically defined methods - when a singleton method is defined inside a module callback - when the method does not match - registers an offense - when the method matches - does not register an offense - when the variable name matches the method name - does not register an offense - when the variable name does not match the method name - registers an offense - when a method is defined inside a module callback - when the method matches - does not register an offense - when the method does not match - registers an offense - when defined?-based memoization is used - does not register an offense with a leading `_` for both names - registers an offense when it has leading `_` but names do not match - registers an offense when names match but missing a leading _ - with dynamically defined methods - when a singleton method is defined inside a module callback - when the method does not match - registers an offense - when the method matches - does not register an offense - when a method is defined inside a module callback - when the method matches - does not register an offense - when the method does not match - registers an offense - when the variable name does not match the method name - registers an offense - when the variable name matches the method name - does not register an offense +RuboCop::Cop::Bundler::DuplicatedGem + when investigating Gemfiles + does not register an offense when gem is duplicated within `if-elsif` statement + does not register an offense when gem is duplicated within `if-else` statement + does not register an offense when gem is duplicated within `case` statement + registers an offense when gem from default group is conditionally duplicated + and a duplicated gem is in a git/path/group/platforms block + registers an offense + and no duplicate gems are present + does not register any offenses + and the file is empty + does not register any offenses + and a gem is duplicated in default group + registers an offense + when investigating Ruby files + does not register any offenses -RuboCop::Cop::Style::Dir - when using `#dirname` and `#realpath` +RuboCop::Cop::Lint::ImplicitStringConcatenation + on adjacent string literals on the same line registers an offense - registers an offense with ::File - when using `#expand_path` and `#dirname` - registers an offense with ::File + on a string with interpolations + does register an offense + on adjacent string literals on different lines + does not register an offense + when the string literals contain newlines + does not register an offense for a single string registers an offense + when inside an array + notes that the strings could be separated by a comma instead + when in a method call's argument list + notes that the strings could be separated by a comma instead + on a single string literal + does not register an offense -RuboCop::Cop::Style::FrozenStringLiteralComment - always - accepts an emacs style combined magic comment - registers an offense for not having a frozen string literal comment under an encoding comment separated by a newline - accepts a frozen string literal comment below shebang above an encoding comments - accepts a disabled frozen string literal comment below shebang above an encoding comments - registers an offense for having a frozen string literal comment under ruby code - accepts a disabled frozen string literal below a shebang comment - registers an offense for not having a frozen string literal comment when there is only a shebang - registers an offense for not having a frozen string literal comment under an encoding comment - registers an offense for arbitrary tokens - accepts a disabled frozen string literal comment below shebang and encoding comments - registers an offense for not having a frozen string literal comment on the top line - accepts a frozen string literal comment after other comments - accepts a disabled frozen string literal below an encoding comment - accepts a disabled frozen string literal on the top line - accepts a source with no tokens - registers an offense with an empty line between magic comments and the code - accepts a frozen string literal comment below newline-separated magic comments - accepts a frozen string literal comment below shebang and encoding comments - accepts a frozen string literal on the top line - registers an offense for not having a frozen string literal comment under a shebang - registers an offense for an extra first empty line - registers an offense for not having a frozen string literal comment under a shebang and an encoding comment - accepts an empty source - accepts a frozen string literal below a shebang comment - accepts a frozen string literal below an encoding comment - always_true - accepts a frozen string literal comment below shebang above an encoding comments - registers an offense for arbitrary tokens below shebang, an encoding comment, and extra space - accepts a frozen string literal comment below an encoding comment and extra space - registers an offense for arbitrary tokens above an empty line - accepts a frozen string literal below a shebang comment - registers an offense for arbitrary tokens below shebang and encoding comments - registers an offense for a disabled frozen string literal below an encoding comment - registers an offense for a disabled frozen string literal below a shebang comment - registers an offense for a disabled frozen string literal comment under shebang with no other code - registers an offense for a disabled frozen string literal comment below an encoding comment and extra space - accepts an empty source - accepts a frozen string literal below an encoding comment - registers an offense for a disabled frozen string literal comment after other comments - registers an offense for arbitrary tokens - registers an offense for a disabled frozen string literal comment below shebang above an encoding comments - registers an offense for not having a frozen string literal comment under an encoding comment - registers an offense for a disabled frozen string literal comment below shebang, an encoding comment, and extra space - registers an offense for not having a frozen string literal comment under an encoding comment and extra space - accepts a source with no tokens - registers an offense for having a frozen string literal comment under ruby code - registers an offense for arbitrary tokens below an encoding comment and extra space - accepts a frozen string literal comment under shebang with no other code - accepts an emacs style combined magic comment - registers an offense for arbitrary tokens below an encoding comment - accepts a frozen string literal on the top line - registers an offense for arbitrary tokens below a shebang comment - registers an offense for a disabled frozen string literal - registers an offense for arbitrary tokens under shebang with no other code - registers an offense for not having a frozen string literal comment on the top line - registers an offense for not having a frozen string literal comment under shebang with no other code - registers an offense for an extra first empty line - registers an offense for not having a frozen string literal comment under a shebang and an encoding comment - registers an offense for arbitrary tokens below shebang above an encoding comments - registers an offense for a disabled frozen string literal on the top line - accepts a frozen string literal comment below shebang and encoding comments - registers an offense for a disabled frozen string literal comment below shebang and encoding comments - registers an offense for not having a frozen string literal comment under a shebang, an encoding comment, and extra space - accepts a frozen string literal comment after other comments - accepts a frozen string literal comment below shebang, an encoding comment, and extra space - registers an offense for a disabled frozen string literal above an empty line - target_ruby_version < 2.3 - accepts calling << on a string with interpolation - accepts freezing a string - accepts freezing a string with interpolation - accepts calling << on a string - never - allows not having a frozen string literal comment under a shebang and an encoding comment - registers an offense for a frozen string literal comment below a shebang comment - registers an offense for a disabled frozen string literal comment on the top line - accepts not having not having a frozen string literal comment under a shebang - registers an offense for having a frozen string literal comment after other comments - registers an offense for a frozen string literal comment below shebang and encoding comments - registers an offense for a frozen string literal comment on the top line - registers an offense for a disabled frozen string literal comment below shebang above an encoding comments - registers an offense for a disabled frozen string literal below an encoding comment - registers an offense for a disabled frozen string literal comment below shebang and encoding comments - registers an offense for a frozen string literal comment below shebang above an encoding comments - accepts a frozen string literal comment under ruby code - accepts an empty source - accepts a source with no tokens - allows not having a frozen string literal comment under an encoding comment - registers an offense for a disabled frozen string literal below a shebang comment - registers an offense for a frozen string literal comment below an encoding comment - accepts not having a frozen string literal comment on the top line - -RuboCop::Cop::Style::WhileUntilModifier - behaves like condition modifier cop - for a multiline 'until' - doesn't break when used as RHS of local var assignment - accepts it if body spans more than one line - doesn't break when used as RHS of constant assignment - corrects it when assignment is in body - handles one-line usage - corrects it if result fits in one line - doesn't break when used as RHS of binary arithmetic - accepts it if single line would not fit on one line - doesn't break when used as RHS of instance var assignment - doesn't break when used as RHS of class var assignment - accepts an empty body - accepts it when condition has local variable assignment - handles inline comments during autocorrection - accepts multiline condition in modifier form - registers an offense - when Layout/LineLength is disabled - registers an offense even for a long modifier statement - when there is a comment on the first line and some code after the end keyword - does not register an offense - behaves like condition modifier cop - for a multiline 'while' - doesn't break when used as RHS of class var assignment - doesn't break when used as RHS of local var assignment - doesn't break when used as RHS of constant assignment - corrects it if result fits in one line - accepts it if body spans more than one line - corrects it when assignment is in body - handles inline comments during autocorrection - handles one-line usage - accepts it if single line would not fit on one line - doesn't break when used as RHS of binary arithmetic - accepts an empty body - doesn't break when used as RHS of instance var assignment - accepts it when condition has local variable assignment - when there is a comment on the first line and some code after the end keyword - does not register an offense - when Layout/LineLength is disabled - registers an offense even for a long modifier statement - accepts multiline condition in modifier form - registers an offense - -RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks - when argument starts on same line but ends on different line - registers an offense and corrects - when two arguments are on next line - does not add any offenses - when many arguments are on multiple lines, two on same line - registers an offense and corrects - when bracket hash assignment key on multiple lines - does not add any offenses - when many arguments including hash are on multiple lines, three on same line - registers an offense and corrects - when there are multiple arguments on the first line - registers an offense and corrects starting from the 2nd argument - when many arguments are on multiple lines, three on same line - registers an offense and corrects - when bracket hash assignment on multiple lines - does not add any offenses - when one argument on same line - does not add any offenses - when second argument starts on same line as end of first - registers an offense and corrects - -RuboCop::Cop::Style::RedundantStringEscape - does not register an offense for a __FILE__ literal - does not register an offense for a x-str literal - does not register an offense for a __dir__ literal - does not register an offense for a regexp literal - with a %W(...) literal - does not register an offense for escaped spaces - behaves like a literal with interpolation - does not register an offense for a newline - does not register an offense for a meta character - does not register an offense for a unicode escape - does not register a bracket-escaped lvar interpolation - registers an offense and corrects an escaped double quote - does not register an offense for an ascii DEL - does not register an offense for an escaped backslash - does not register an offense for an octal escape - does not register an offense for an escaped # followed { - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an escaped delimiter - does not register an offense for a $-escaped gvar interpolation - does not register an offense for an escaped newline - registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation - registers an offense and corrects an escaped single quote - does not register an offense for multiple unicode escapes - registers an offense and corrects an escaped # at end-of-string - does not register an offense for meta control characters - does not register an offense without escapes - does not register an offense for a technically-unnecessary escape - does not register an offense for an escaped gvar interpolation - does not register an offense for a hex escape - does not register an offense for control characters - does not register an offense for an escaped interpolation - registers an offense and corrects an escaped # without following { - does not register an offense for a @-escaped ivar interpolation - registers an offense and corrects a escaped nested delimiter in a double quoted string - registers an offense and corrects an escaped # before interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for an escaped cvar interpolation - does not register an offense for a @-escaped cvar interpolation - does not register an offense for a bracket-escaped interpolation - with a %Q(...) literal - behaves like a literal with interpolation - registers an offense and corrects an escaped double quote - does not register an offense for an escaped newline - registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense for an octal escape - does not register a bracket-escaped lvar interpolation - does not register an offense for an escaped delimiter before interpolation - does not register an offense for a @-escaped ivar interpolation - does not register an offense for an escaped delimiter - registers an offense and corrects an escaped single quote - does not register an offense for multiple unicode escapes - does not register an offense for a meta character - does not register an offense for an escaped ivar interpolation - does not register an offense for a bracket-escaped interpolation - does not register an offense for control characters - registers an offense and corrects an escaped # without following { - does not register an offense for a $-escaped gvar interpolation - does not register an offense without escapes - does not register an offense for meta control characters - does not register an offense for an escaped backslash - does not register an offense for a unicode escape - does not register an offense for an escaped cvar interpolation - does not register an offense for a technically-unnecessary escape - does not register an offense for a newline - does not register an offense for a @-escaped cvar interpolation - does not register an offense for an escaped # followed { - does not register an offense for an escaped interpolation - does not register an offense for a hex escape - does not register an offense for an ascii DEL - registers an offense and corrects a escaped nested delimiter in a double quoted string - registers an offense and corrects an escaped # before interpolation - registers an offense and corrects an escaped # at end-of-string - with a %q(...) literal - behaves like a literal without interpolation - does not register an offense for meta control characters - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an escaped interpolation - does not register a bracket-escaped lvar interpolation - does not register an offense for an escaped # with following { - does not register an offense for a technically-unnecessary escape - does not register an offense for an escaped delimiter - does not register an offense without escapes - does not register an offense for an escaped gvar interpolation - does not register an offense for an escaped # followed { - does not register an offense with escaped # without following { - does not register an offense for an escaped backslash - does not register an offense for an allowed escape inside multi-line literal - does not register an offense for a bracket-escaped interpolation - does not register an offense for a @-escaped cvar interpolation - does not register an offense for multiple unicode escapes - does not register an offense with escaped single quote - does not register an offense for a $-escaped gvar interpolation - does not register an offense for a unicode escape - does not register an offense for an octal escape - does not register an offense with escaped # at end-of-string - does not register an offense with escaped double quote - does not register an offense for an escaped cvar interpolation - does not register an offense for a newline - does not register an offense for a @-escaped ivar interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for a hex escape - does not register an offense for a meta character - does not register an offense for an ascii DEL - does not register an offense for an escaped newline - does not register an offense for control characters - with an interpolation-disabled HEREDOC - behaves like a literal without interpolation - does not register an offense for an allowed escape inside multi-line literal - does not register an offense for a meta character - does not register an offense with escaped single quote - does not register an offense for a @-escaped ivar interpolation - does not register an offense for meta control characters - does not register an offense for an escaped # with following { - does not register an offense for an escaped backslash - does not register an offense with escaped # without following { - does not register an offense for a $-escaped gvar interpolation - does not register an offense for a @-escaped cvar interpolation - does not register a bracket-escaped lvar interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense with escaped # at end-of-string - does not register an offense for a hex escape - does not register an offense with escaped double quote - does not register an offense for an escaped # followed { - does not register an offense for a newline - does not register an offense for an escaped interpolation - does not register an offense for an octal escape - does not register an offense for an escaped newline - does not register an offense for an ascii DEL - does not register an offense for a technically-unnecessary escape - does not register an offense without escapes - does not register an offense for a unicode escape - does not register an offense for an escaped cvar interpolation - does not register an offense for multiple unicode escapes - does not register an offense for a bracket-escaped interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for control characters - when using character literals - does not register an offense for `?\n` - does not register an offense for `?a` - with a double quoted string - registers an offense and corrects an unnecessary escape in multi-line broken string - does not register an offense with multiple escaped backslashes - does not register an offense with escaped double quote - does not register an offense when escaping a quote in multi-line broken string - behaves like a literal with interpolation - registers an offense and corrects an escaped # before interpolation - does not register an offense for an escaped # followed { - does not register an offense for meta control characters - does not register an offense without escapes - does not register an offense for an escaped newline - does not register an offense for a @-escaped ivar interpolation - does not register an offense for a hex escape - does not register an offense for an ascii DEL - registers an offense and corrects an escaped single quote - does not register an offense for an octal escape - does not register an offense for a technically-unnecessary escape - does not register an offense for an escaped interpolation - does not register an offense for control characters - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense for a @-escaped cvar interpolation - does not register an offense for an escaped cvar interpolation - registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for a $-escaped gvar interpolation - does not register an offense for an escaped delimiter - does not register an offense for a meta character - registers an offense and corrects an escaped # without following { - does not register an offense for multiple unicode escapes - does not register an offense for a bracket-escaped interpolation - does not register an offense for a unicode escape - does not register a bracket-escaped lvar interpolation - does not register an offense for a newline - registers an offense and corrects an escaped # at end-of-string - does not register an offense for an escaped backslash - with an interpolation-enabled HEREDOC - does not register an offense for a $-escaped gvar interpolation - registers an offense and corrects an escaped # at end-of-string - does not register an offense for an escaped cvar interpolation - does not register an offense for a newline - does not register an offense for an escaped newline - does not register an offense for a hex escape - does not register an offense for multiple unicode escapes - does not register an offense for an ascii DEL - does not register an offense for a technically-unnecessary escape - does not register an offense for a heredoc interpolating a string with an allowed escape - does not register an offense for a unicode escape - does not register an offense for meta control characters - registers an offense and corrects an escaped # before interpolation - does not register an offense for an escaped backslash - does not register an offense for an octal escape - does not register an offense for control characters - does not register an offense for an escaped gvar interpolation - does not register an offense for a @-escaped cvar interpolation - registers an offense and corrects an escaped single quote - does not register an offense for a meta character - does not register an offense for a bracket-escaped interpolation - does not register an offense for a nested heredoc without interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for a @-escaped ivar interpolation - does not register an offense for an escaped interpolation - does not register an offense for an escaped # followed { - registers an offense and corrects an escaped # without following { - does not register an offense without escapes - does not register a bracket-escaped lvar interpolation - with a %(...) literal - behaves like a literal with interpolation - does not register an offense for an ascii DEL - registers an offense and corrects an escaped single quote - does not register an offense for a unicode escape - does not register an offense for a hex escape - does not register an offense for an escaped backslash - does not register an offense for a $-escaped gvar interpolation - does not register an offense for an escaped delimiter - does not register an offense for an escaped ivar interpolation - does not register an offense for a meta character - registers an offense and corrects an escaped # without following { - does not register an offense for a bracket-escaped interpolation - does not register an offense for an escaped delimiter before interpolation - registers an offense and corrects an escaped # at end-of-string - does not register an offense for a @-escaped ivar interpolation - registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation - registers an offense and corrects a escaped nested delimiter in a double quoted string - does not register an offense for an escaped cvar interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense for a technically-unnecessary escape - does not register an offense for multiple unicode escapes - does not register a bracket-escaped lvar interpolation - does not register an offense without escapes - does not register an offense for an escaped # followed { - does not register an offense for an escaped interpolation - does not register an offense for an octal escape - does not register an offense for control characters - registers an offense and corrects an escaped # before interpolation - does not register an offense for an escaped newline - does not register an offense for a @-escaped cvar interpolation - does not register an offense for meta control characters - does not register an offense for a newline - registers an offense and corrects an escaped double quote - with a single quoted string - behaves like a literal without interpolation - does not register an offense for an escaped ivar interpolation - does not register an offense for a meta character - does not register an offense for an escaped cvar interpolation - does not register an offense with escaped # without following { - does not register an offense for control characters - does not register an offense for an ascii DEL - does not register an offense with escaped double quote - does not register an offense for a @-escaped cvar interpolation - does not register an offense for an escaped # with following { - does not register an offense for a $-escaped gvar interpolation - does not register an offense for a bracket-escaped interpolation - does not register an offense for an octal escape - does not register an offense for an escaped backslash - does not register an offense for an escaped delimiter - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an escaped # followed { - does not register a bracket-escaped lvar interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense without escapes - does not register an offense for a technically-unnecessary escape - does not register an offense for an escaped interpolation - does not register an offense for a @-escaped ivar interpolation - does not register an offense with escaped single quote - does not register an offense for multiple unicode escapes - does not register an offense for an allowed escape inside multi-line literal - does not register an offense for an escaped newline - does not register an offense for a newline - does not register an offense for a hex escape - does not register an offense for a unicode escape - does not register an offense with escaped # at end-of-string - does not register an offense for meta control characters - with a %Q!...! literal - behaves like a literal with interpolation - registers an offense and corrects an escaped single quote - does not register an offense for meta control characters - does not register an offense for an escaped ivar interpolation - does not register an offense for an escaped # followed { - registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation - registers an offense and corrects an escaped # at end-of-string - does not register an offense for a unicode escape - registers an offense and corrects a escaped nested delimiter in a double quoted string - does not register an offense for a hex escape - does not register an offense for an escaped newline - does not register a bracket-escaped lvar interpolation - does not register an offense for an octal escape - does not register an offense for multiple unicode escapes - does not register an offense for an escaped backslash - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an escaped interpolation - does not register an offense for a meta character - registers an offense and corrects an escaped # before interpolation - does not register an offense for a $-escaped gvar interpolation - registers an offense and corrects an escaped # without following { - does not register an offense for an escaped cvar interpolation - does not register an offense for an escaped delimiter - does not register an offense for an escaped gvar interpolation - does not register an offense for a newline - does not register an offense for a @-escaped cvar interpolation - does not register an offense for a bracket-escaped interpolation - does not register an offense without escapes - registers an offense and corrects an escaped double quote - does not register an offense for a technically-unnecessary escape - does not register an offense for a @-escaped ivar interpolation - does not register an offense for control characters - does not register an offense for an ascii DEL - with a %w(...) literal - does not register an offense for escaped spaces - behaves like a literal without interpolation - does not register an offense for a meta character - does not register an offense for an ascii DEL - does not register an offense with escaped # at end-of-string - does not register an offense for an escaped ivar interpolation - does not register an offense for an escaped delimiter before interpolation - does not register an offense for an allowed escape inside multi-line literal - does not register an offense for an escaped newline - does not register an offense for a technically-unnecessary escape - does not register an offense with escaped double quote - does not register an offense for an escaped interpolation - does not register an offense for an escaped backslash - does not register an offense with escaped # without following { - does not register an offense for meta control characters - does not register an offense without escapes - does not register an offense for a newline - does not register an offense for control characters - does not register a bracket-escaped lvar interpolation - does not register an offense for multiple unicode escapes - does not register an offense with escaped single quote - does not register an offense for an octal escape - does not register an offense for an escaped cvar interpolation - does not register an offense for a $-escaped gvar interpolation - does not register an offense for a bracket-escaped interpolation - does not register an offense for an escaped gvar interpolation - does not register an offense for an escaped # with following { - does not register an offense for a @-escaped cvar interpolation - does not register an offense for an escaped # followed { - does not register an offense for a hex escape - does not register an offense for a @-escaped ivar interpolation - does not register an offense for an escaped delimiter - does not register an offense for a unicode escape - -RuboCop::Cop::Style::RescueModifier - handles more complex expression with modifier rescue - handles modifier rescue in normal rescue - handles modifier rescue in a method - does not register an offense for normal rescue with ensure - registers an offense for modifier rescue - does not register an offense for normal rescue - does not register an offense for nested normal rescue - handles parentheses around a rescue modifier - registers an offense for modifier rescue around parallel assignment - when a singleton method has implicit begin - handles modifier rescue in body of implicit begin - accepts normal rescue - autocorrect - corrects doubled rescue modifiers - corrects complex rescue modifier - excluded file - processes excluded files with issue - when an instance method has implicit begin - handles modifier rescue in body of implicit begin - accepts normal rescue - -RuboCop::Formatter::AutoGenConfigFormatter - #finished - calls #report_summary - when any offenses are detected - does not report offenses - outputs report summary - when no offenses are detected - does not report offenses - #report_file_as_mark - when a refactor severity offense is detected - prints "R" - when no offenses are detected - prints "." - when different severity offenses are detected - prints highest level mark - when a refactor convention offense is detected - prints "C" - -RuboCop::Cop::Style::ArrayJoin - autocorrects '*' to 'join' when there are no spaces - autocorrects '*' to 'join' when setting to a variable - does not register an offense for numbers - does not register an offense for ambiguous cases - registers an offense for an array followed by string - -RuboCop::Cop::InternalAffairs::MethodNameEqual - does not register an offense when using `#method?` - registers an offense when using `#method == other_node.do_something` - registers an offense when using `#method == :do_something` - -RuboCop::Cop::Lint::RedundantRequireStatement - registers an offense when using requiring `enumerator` - registers an offense when using requiring `enumerator` in condition - registers an offense when using requiring `enumerator` with modifier form - target ruby version >= 2.1 - register an offense and corrects when using requiring `thread` or already redundant features - target ruby version >= 2.2 - registers an offense when using requiring `rational`, `complex` - target ruby version >= 2.7 - registers an offense when using requiring `ruby2_keywords` or already redundant features - target ruby version < 3.1 - does not register an offense and corrects when using requiring `fiber` - target ruby version >= 3.1 - registers an offense and corrects when using requiring `fiber` or already redundant features - target ruby version >= 3.2 - registers an offense and corrects when using requiring `set` - target ruby version <= 2.0 - does not register an offense when using requiring `thread` - target ruby version <= 2.4 - does not register an offense when using requiring `pp` - target ruby version <= 2.1 - does not register an offense when using requiring `rational`, `complex` - target ruby version >= 2.5 - register an offense and corrects when using requiring `pp` or already redundant features - target ruby version <= 2.6 - does not register an offense when using requiring `ruby2_keywords` - -RuboCop::Cop::Naming::VariableNumber - when configured for non integer - registers an offense for snake case numbering in symbol - registers an offense for normal case numbering in symbol - registers an offense for normal case numbering in method camel case parameter - registers an offense for normal case numbering in method parameter - registers an offense for snake case numbering in method name - registers an offense for snake case numbering in method camel case parameter - registers an offense for normal case numbering in method name - registers an offense for snake case numbering in method parameter - behaves like accepts - accepts localone in non_integer - behaves like offense_array - registers an offense for ["a_1", "aone"] in non_integer - behaves like offense - registers an offense for @myAttribute_1 in non_integer - behaves like offense - registers an offense for _myLocal1 in non_integer - behaves like accepts - accepts fooBar in non_integer - behaves like accepts - accepts @__foo__ in non_integer - behaves like offense - registers an offense for myAttribute1 in non_integer - behaves like accepts - accepts local_ in non_integer - behaves like offense - registers an offense for local_1 in non_integer - behaves like accepts - accepts @@foo in non_integer - behaves like offense - registers an offense for @myAttribute1 in non_integer - behaves like offense - registers an offense for local1 in non_integer - behaves like accepts - accepts emparejó in non_integer - behaves like accepts - accepts _foo in non_integer - behaves like accepts - accepts _ in non_integer - behaves like offense - registers an offense for myAttribute_1 in non_integer - behaves like accepts - accepts _1 in non_integer - behaves like accepts - accepts @foo in non_integer - behaves like offense - registers an offense for @local1 in non_integer - behaves like offense - registers an offense for @local_1 in non_integer - behaves like accepts integer symbols - accepts integer symbol - accepts integer symbol array literal - behaves like offense - registers an offense for _myLocal_1 in non_integer - behaves like accepts - accepts local_one in non_integer - when configured for normal - does not register an offense for normal case numbering in symbol - registers an offense for snake case numbering in method name - registers an offense for snake case numbering in a global variable name - registers an offense for snake case numbering in method camel case parameter - registers an offense for snake case numbering in symbol - registers an offense for snake case numbering in method parameter - behaves like offense - registers an offense for sha_256 in normalcase - behaves like offense - registers an offense for local_FOO_1 in normalcase - behaves like accepts - accepts sha256 in normalcase - behaves like accepts - accepts local_ in normalcase - behaves like offense - registers an offense for localFOO_1 in normalcase - behaves like accepts - accepts user_1_id in normalcase - behaves like accepts - accepts user1_id in normalcase - behaves like offense - registers an offense for myAttribute_1 in normalcase - behaves like offense - registers an offense for @@local_1 in normalcase - behaves like accepts - accepts @foo in normalcase - behaves like accepts - accepts snake_case in normalcase - behaves like accepts - accepts localFOO1 in normalcase - behaves like offense - registers an offense for _myLocal_1 in normalcase - behaves like offense_array - registers an offense for ["a_1", "a2"] in normalcase - behaves like accepts - accepts foo10_bar in normalcase - behaves like accepts - accepts target_u2f_device in normalcase - behaves like accepts - accepts @__foo__ in normalcase - behaves like accepts - accepts _ in normalcase - behaves like offense - registers an offense for local_1 in normalcase - behaves like offense - registers an offense for @myAttribute_1 in normalcase - behaves like accepts - accepts _1 in normalcase - behaves like accepts integer symbols - accepts integer symbol - accepts integer symbol array literal - behaves like accepts - accepts _foo in normalcase - behaves like accepts - accepts emparejó in normalcase - behaves like accepts - accepts local1 in normalcase - behaves like offense - registers an offense for @local_1 in normalcase - when AllowedPatterns is set - registers an offense for a local variable name that does not match an allowed pattern - does not register an offense for a class variable name that matches an allowed pattern - registers an offense for a global variable name that does not match an allowed pattern - does not register an offense for a symbol that matches an allowed pattern - does not register an offense for a method name that matches an allowed pattern - registers an offense for a symbol that does not match an allowed pattern - registers an offense for a method name that does not match an allowed pattern - does not register an offense for a local variable name that matches an allowed pattern - does not register an offense for a instance variable name that matches an allowed pattern - registers an offense for a instance variable name that does not match an allowed pattern - does not register an offense for a global variable name that matches an allowed pattern - registers an offense for a class variable name that does not match an allowed pattern - when AllowedIdentifiers is set - does not register an offense for a global variable name that is allowed - does not register an offense for a instance variable name that is allowed - does not register an offense for a method name that is allowed - does not register an offense for a local variable name that is allowed - does not register an offense for a class variable name that is allowed - does not register an offense for a symbol that is allowed - when CheckSymbols is false - does not register an offense for snake case numbering in symbol - when CheckMethodNames is false - does not register an offense for snake case numbering in method name - when configured for snake_case - registers an offense for normal case numbering in symbol - registers an offense for normal case numbering in method parameter - does not register an offense for snake case numbering in symbol - registers an offense for normal case numbering in method camel case parameter - registers an offense for normal case numbering in a global variable name - registers an offense for normal case numbering in method name - behaves like accepts - accepts a_1_b_1 in snake_case - behaves like accepts - accepts local_ in snake_case - behaves like accepts - accepts local_123 in snake_case - behaves like offense - registers an offense for @local1 in snake_case - behaves like accepts - accepts @__foo__ in snake_case - behaves like accepts integer symbols - accepts integer symbol - accepts integer symbol array literal - behaves like offense - registers an offense for _unused1 in snake_case - behaves like offense - registers an offense for @@local1 in snake_case - behaves like accepts - accepts _ in snake_case - behaves like accepts - accepts @foo in snake_case - behaves like offense_array - registers an offense for ["a1", "a_2"] in snake_case - behaves like accepts - accepts _foo in snake_case - behaves like accepts - accepts local_1 in snake_case - behaves like offense - registers an offense for @camelCase1 in snake_case - behaves like accepts - accepts local_12 in snake_case - behaves like accepts - accepts aB_1 in snake_case - behaves like offense - registers an offense for aB1 in snake_case - behaves like offense - registers an offense for local1 in snake_case - behaves like accepts - accepts emparejó in snake_case - behaves like accepts - accepts _1 in snake_case - behaves like accepts - accepts a_1_b in snake_case - behaves like offense - registers an offense for camelCase1 in snake_case - -RuboCop::Cop::Style::BarePercentLiterals - when EnforcedStyle is bare_percent - and strings are dynamic - accepts "" - accepts "" string with interpolation - registers an offense for %Q() - accepts regular expressions - accepts %() - accepts heredoc - accepts %q - accepts __FILE__ - accepts '' - and strings are static - accepts heredoc - accepts regular expressions - accepts %q - accepts __FILE__ - accepts "" string with interpolation - accepts "" - accepts %() - registers an offense for %Q() - accepts '' - when EnforcedStyle is percent_q - and strings are dynamic - registers an offense for %() - accepts "" - accepts regular expressions - accepts '' - accepts __FILE__ - accepts %q - accepts %Q() - accepts "" string with interpolation - accepts heredoc - and strings are static - registers an offense for %() - accepts heredoc - accepts %q - accepts "" - accepts __FILE__ - accepts regular expressions - accepts '' - accepts %Q() - accepts "" string with interpolation - -RuboCop::Cop::Style::NumberedParameters - >= Ruby 2.7 - EnforcedStyle: disallow - does an offense when using numbered parameters even with single-line blocks - EnforcedStyle: allow_single_line - does not register an offense when using numbered parameters with single-line blocks - registers an offense when using numbered parameters with multi-line blocks - -RuboCop::Cop::Layout::ClosingHeredocIndentation - does not register an offense for a << heredoc - accepts correctly indented closing heredoc when heredoc contents is after closing heredoc - accepts correctly indented closing heredoc when heredoc contents with blank line - accepts correctly indented closing heredoc when aligned at the beginning of method definition and using `strip_indent` - accepts correctly indented closing heredoc when aligned at the beginning of method definition - does not register an offense for correctly indented empty heredocs - accepts correctly indented closing heredoc when aligned at the beginning of method definition and content is empty - registers an offense for bad indentation of a closing heredoc - accepts correctly indented closing heredoc when heredoc contents is before closing heredoc - accepts correctly indented closing heredoc - registers an offense for incorrectly indented empty heredocs +RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral + accepts non array percent literals + for W type and ["(", ")"] delimiters + accepts literals with escaped spaces + accepts multi-line literals within a method + registers an offense for multiple spaces between items + accepts newlines and additional following alignment spaces + accepts multi-line literals + accepts literals with escaped and additional spaces + accepts literals without additional spaces + registers an offense for unnecessary spaces + for i type and ["[", "]"] delimiters + accepts multi-line literals within a method + accepts literals with escaped spaces + accepts multi-line literals + accepts literals with escaped and additional spaces + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts literals without additional spaces + registers an offense for multiple spaces between items + for i type and ["!", "!"] delimiters + registers an offense for multiple spaces between items + accepts literals without additional spaces + accepts multi-line literals within a method + accepts literals with escaped spaces + accepts multi-line literals + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts literals with escaped and additional spaces + for I type and ["(", ")"] delimiters + accepts literals with escaped spaces + registers an offense for multiple spaces between items + accepts multi-line literals + registers an offense for unnecessary spaces + accepts literals without additional spaces + accepts multi-line literals within a method + accepts literals with escaped and additional spaces + accepts newlines and additional following alignment spaces + for W type and ["[", "]"] delimiters + accepts multi-line literals within a method + accepts newlines and additional following alignment spaces + accepts multi-line literals + registers an offense for unnecessary spaces + accepts literals without additional spaces + accepts literals with escaped spaces + accepts literals with escaped and additional spaces + registers an offense for multiple spaces between items + for I type and ["{", "}"] delimiters + accepts newlines and additional following alignment spaces + accepts literals with escaped and additional spaces + registers an offense for unnecessary spaces + accepts literals without additional spaces + accepts multi-line literals within a method + accepts multi-line literals + accepts literals with escaped spaces + registers an offense for multiple spaces between items + for w type and ["(", ")"] delimiters + accepts newlines and additional following alignment spaces + accepts multi-line literals within a method + accepts literals with escaped and additional spaces + registers an offense for unnecessary spaces + registers an offense for multiple spaces between items + accepts literals with escaped spaces + accepts multi-line literals + accepts literals without additional spaces + for I type and ["!", "!"] delimiters + accepts newlines and additional following alignment spaces + registers an offense for multiple spaces between items + accepts literals with escaped spaces + registers an offense for unnecessary spaces + accepts literals with escaped and additional spaces + accepts multi-line literals + accepts literals without additional spaces + accepts multi-line literals within a method + for i type and ["(", ")"] delimiters + accepts newlines and additional following alignment spaces + accepts multi-line literals within a method + accepts multi-line literals + registers an offense for multiple spaces between items + accepts literals with escaped spaces + registers an offense for unnecessary spaces + accepts literals without additional spaces + accepts literals with escaped and additional spaces + for w type and ["{", "}"] delimiters + accepts literals without additional spaces + accepts newlines and additional following alignment spaces + accepts multi-line literals + accepts literals with escaped and additional spaces + registers an offense for unnecessary spaces + registers an offense for multiple spaces between items + accepts literals with escaped spaces + accepts multi-line literals within a method + for W type and ["{", "}"] delimiters + accepts literals with escaped and additional spaces + accepts newlines and additional following alignment spaces + accepts literals with escaped spaces + registers an offense for unnecessary spaces + registers an offense for multiple spaces between items + accepts literals without additional spaces + accepts multi-line literals within a method + accepts multi-line literals + for w type and ["!", "!"] delimiters + accepts multi-line literals + accepts literals with escaped spaces + accepts newlines and additional following alignment spaces + accepts multi-line literals within a method + registers an offense for unnecessary spaces + registers an offense for multiple spaces between items + accepts literals with escaped and additional spaces + accepts literals without additional spaces + for w type and ["[", "]"] delimiters + registers an offense for unnecessary spaces + accepts newlines and additional following alignment spaces + accepts literals without additional spaces + accepts literals with escaped spaces + accepts multi-line literals within a method + registers an offense for multiple spaces between items + accepts multi-line literals + accepts literals with escaped and additional spaces + for i type and ["{", "}"] delimiters + accepts multi-line literals within a method + registers an offense for multiple spaces between items + accepts literals with escaped and additional spaces + registers an offense for unnecessary spaces + accepts multi-line literals + accepts newlines and additional following alignment spaces + accepts literals with escaped spaces + accepts literals without additional spaces + for I type and ["[", "]"] delimiters + accepts literals with escaped spaces + accepts literals without additional spaces + accepts literals with escaped and additional spaces + registers an offense for unnecessary spaces + accepts newlines and additional following alignment spaces + registers an offense for multiple spaces between items + accepts multi-line literals + accepts multi-line literals within a method + for W type and ["!", "!"] delimiters + accepts literals with escaped spaces + accepts literals without additional spaces + accepts newlines and additional following alignment spaces + registers an offense for unnecessary spaces + accepts literals with escaped and additional spaces + registers an offense for multiple spaces between items + accepts multi-line literals + accepts multi-line literals within a method RuboCop::Cop::Style::RedundantRegexpEscape - with a single-line %r{} regexp - with an escaped { or } inside a character class - does not register an offense - without escapes - does not register an offense - with an escaped { or } outside a character class - does not register an offense - with redundantly-escaped slashes + with a single-line `//` regexp + with an interpolated unnecessary-escape regexp registers an offense and corrects - with a single-line %r() regexp - with escaped delimiters outside a character-class - does not register an offense - with escaped delimiters inside a character-class - does not register an offense - with escaped delimiters and regexp options + with an escaped ' ' outside a character class does not register an offense without escapes does not register an offense - with multibyte characters - removes the escape character at the right position - with a multi-line %r{} regexp - without escapes + with an escaped 'W' inside a character class does not register an offense - with redundantly-escaped slashes - registers an offense and corrects - with a # inside a character class + with an escaped '|' outside a character class does not register an offense - with a redundant escape after a line with comment + with an escaped '-' inside a character class registers an offense and corrects - with a single-line %r@@ regexp - with escaped delimiters outside a character-class + with an escaped '*' inside a character class + registers an offense and corrects + with an escaped 'z' outside a character class does not register an offense - with escaped delimiters inside a character-class + with an escaped '#' outside a character class does not register an offense - without escapes + with regexp options and a redundant escape + registers offenses and corrects + with an escaped 'O' outside a character class does not register an offense - with escaped delimiters and regexp options + with an escaped 'd' outside a character class does not register an offense - with a single-line %r!! regexp - without escapes + with an escaped 'B' inside a character class does not register an offense - with escaped delimiters outside a character-class + with an escaped 'm' outside a character class does not register an offense - with escaped delimiters and regexp options + with an escaped 'V' outside a character class does not register an offense - with escaped delimiters inside a character-class + with a line continuation does not register an offense - with a single-line %r<> regexp - with escaped delimiters and regexp options + with an escaped 'F' inside a character class does not register an offense - with escaped delimiters inside a character-class + with an escaped 'X' outside a character class does not register an offense - without escapes + with an escaped 'z' inside a character class does not register an offense - with escaped delimiters outside a character-class + with an escaped 'b' inside a character class does not register an offense - with a single-line %r^^ regexp - without escapes + with an escaped 'r' outside a character class does not register an offense - with escaped delimiters inside a character-class + with an escaped 's' inside a character class does not register an offense - with escaped delimiters outside a character-class + with an escaped 'v' inside a character class does not register an offense - with escaped delimiters and regexp options + with an escaped '\' inside a character class does not register an offense - with a single-line %r// regexp - with escaped slashes + with a nested character class containing redundant escape + registers an offense and corrects + with an interpolation followed by redundant escapes + registers offenses and corrects + with an escaped 'X' inside a character class does not register an offense - without escapes + with an escaped 't' inside a character class does not register an offense - with a single-line `//` regexp - with an escaped '$' inside a character class - registers an offense and corrects - with an escaped 'B' outside a character class + with an escaped '#' inside a character class does not register an offense - with an interpolated unnecessary-escape regexp - registers an offense and corrects - with an escaped '?' inside a character class - registers an offense and corrects - with an escaped 'E' inside a character class + with multiple escaped metachars inside a character class + registers offenses and corrects + with an escaped 'M-a' inside a character class does not register an offense - with an escaped 'X' outside a character class + with an escaped 'a' inside a character class does not register an offense - with an uppercase metacharacter inside a character class + with an escaped 'A' inside a character class does not register an offense - with a nested character class then allowed escape + with a line continuation within a character class does not register an offense - with an escaped '$' outside a character class + with an escaped '^' inside a character class does not register an offense - with an escaped 'b' outside a character class + with an escape inside an interpolated string does not register an offense - with an escaped 'x41' outside a character class + with an escaped 'T' outside a character class does not register an offense - with an escaped 'I' inside a character class + with an escaped '.' outside a character class does not register an offense - with an escaped '(' outside a character class + with an escaped '(' inside a character class + registers an offense and corrects + with an escaped 'S' inside a character class does not register an offense - with an escaped 'p{alpha}' outside a character class + with an escaped ']' inside a character class does not register an offense - with an escaped '}' outside a character class + with an escaped ' +' outside a character class does not register an offense - with an escaped 'e' inside a character class + with an escaped '+' inside a character class + registers an offense and corrects + with an escaped 'Z' inside a character class does not register an offense - with an escaped '|' outside a character class + with an escaped '?' inside a character class + registers an offense and corrects + with a free-spaced mode regex + with a commented redundant escape + does not register an offense + with redundant escape preceded by an escaped comment + registers offenses and corrects + with a commented [ and ] + does not register an offense + with a commented redundant escape on a single line + does not register an offense + with an escaped 'M-a' outside a character class does not register an offense - with an escaped '^' inside a character class + with an escaped 'E' inside a character class does not register an offense - with a line continuation + with an escaped ')' outside a character class does not register an offense - with an escaped 'm' inside a character class + with an escaped 'h' outside a character class does not register an offense - with an escaped '^' outside a character class + with an escaped 'l' outside a character class does not register an offense - with an escaped ')' outside a character class + with an escaped interpolation inside a character class does not register an offense - with an escaped '(' inside a character class + with an escaped '+' inside a character class inside a group registers an offense and corrects - with an escaped 's' outside a character class - does not register an offense - with an escaped ']' outside a character class + with an invalid g escape does not register an offense - with an escaped 'f' inside a character class + with a nested character class then allowed escape does not register an offense - with an escaped 'M-a' inside a character class + with an escaped 'N' inside a character class does not register an offense - with an escaped 'D' outside a character class + with an uppercase metacharacter outside a character class does not register an offense - with an escaped 'D' inside a character class + with an escaped 't' outside a character class does not register an offense - with an escaped 'V' outside a character class + with an escaped 'Q' outside a character class does not register an offense - with an escaped 'O' outside a character class + with an escaped 'P{alpha}' inside a character class does not register an offense - with an escaped 'L' inside a character class + with a POSIX character class then allowed escape inside a character class does not register an offense - with an escaped ')' inside a character class - registers an offense and corrects - with a character class and following escaped char + with an uppercase metacharacter inside a character class does not register an offense - with an escaped 'Y' inside a character class + with an escaped 'cc' outside a character class does not register an offense - with an escaped 'e' outside a character class + with an escaped ' ' inside a character class does not register an offense - with an escaped 'A' inside a character class + with an escaped 'P{alpha}' outside a character class does not register an offense - with an escaped 'y' inside a character class + with an escaped 'd' inside a character class does not register an offense - with an escaped 'u0041' inside a character class + with an escaped 'F' outside a character class does not register an offense - with an escaped 'E' outside a character class + with an escaped 'U' inside a character class does not register an offense - with an escaped 'f' outside a character class + with an escaped 'l' inside a character class does not register an offense + with an escaped '-' outside a character class + registers an offense and corrects with an escaped 'u{0041}' outside a character class does not register an offense - with an escaped 'X' inside a character class - does not register an offense - with an escaped '.' outside a character class + with an escaped 'Y' outside a character class does not register an offense - with an escaped ' ' inside a character class + with an escaped '{' inside a character class + registers an offense and corrects + with an escaped 'x41' inside a character class does not register an offense with an escaped 'r' inside a character class does not register an offense - with an escaped interpolation inside a character class - does not register an offense - with an escaped 'n101' outside a character class + with an escaped '}' outside a character class does not register an offense - with an escaped 't' inside a character class + with an escaped 'G' outside a character class does not register an offense - with an escaped 'F' outside a character class + with an escaped 'n101' inside a character class does not register an offense - with a backreference + with an escaped '$' outside a character class does not register an offense - without escapes + with an escaped 'a' outside a character class does not register an offense - with an escaped '}' inside a character class - registers an offense and corrects - with an escaped 'U' inside a character class + with an escaped 'R' inside a character class does not register an offense - with an uppercase metacharacter outside a character class + with a character class and following escaped char does not register an offense - with an escaped 'z' inside a character class + with an escaped character class and following escaped char does not register an offense - with an escaped '-' character being the last character inside a character class + with an escaped '$' inside a character class registers an offense and corrects - with escaped slashes - does not register an offense - with an escaped '{' outside a character class + with an escaped '|' inside a character class + registers an offense and corrects + with a POSIX character class then disallowed escape inside a character class + registers an offense and corrects + with an escaped 'A' outside a character class does not register an offense - with an escaped 'q' outside a character class + with an escaped 'b' outside a character class does not register an offense - with an escaped 'C-c' inside a character class + with an escaped 'f' inside a character class does not register an offense - with an escaped 'x41' inside a character class + with an escaped '\' outside a character class does not register an offense - with an escaped 'v' outside a character class + with an escaped 'C-c' outside a character class does not register an offense - with an escaped '.' inside a character class - registers an offense and corrects - with an escaped 'd' inside a character class + with an escaped 'W' outside a character class does not register an offense - with an escaped '[' inside a character class + with an escaped 'u0041' outside a character class does not register an offense - with an escaped 'W' inside a character class + with an escaped 'o' outside a character class does not register an offense - with a free-spaced mode regex - with redundant escape preceded by an escaped comment - registers offenses and corrects - with a commented redundant escape on a single line - does not register an offense - with a commented redundant escape - does not register an offense - with a commented [ and ] - does not register an offense - with an escaped '|' inside a character class - registers an offense and corrects - with an escaped '[' outside a character class + with an escaped 'Q' inside a character class does not register an offense - with an escaped '+' outside a character class + with an escaped 'J' inside a character class does not register an offense - with an escaped ' -' outside a character class + with an escaped 'u{0041}' inside a character class does not register an offense - with an escaped '{' inside a character class - registers an offense and corrects - with an escaped 's' inside a character class + with an escaped 'B' outside a character class does not register an offense - with an escaped 'u0041' outside a character class + with an escaped '*' outside a character class does not register an offense - with an escaped 'o' inside a character class + with an escaped 'K' outside a character class does not register an offense - with an escaped 't' outside a character class + with an escaped '+' outside a character class does not register an offense - with an escaped 'n101' inside a character class + with an escaped 'I' outside a character class does not register an offense - with an escaped '#' outside a character class + with an escaped 'cc' inside a character class does not register an offense - with an escaped 'z' outside a character class + with an escaped '{' outside a character class does not register an offense - with an escaped '?' outside a character class + with an escaped 'O' inside a character class does not register an offense - with an escaped 'm' outside a character class + with an escaped 'D' outside a character class does not register an offense - with multiple escaped metachars inside a character class - registers offenses and corrects - with an escaped 'J' inside a character class + with an escaped 'Y' inside a character class does not register an offense - with an escaped 'h' outside a character class + with an escaped 'x41' outside a character class does not register an offense - with an escaped 'i' outside a character class + with an escaped 'R' outside a character class does not register an offense - with an escaped '-' outside a character class - registers an offense and corrects - with an escaped ']' inside a character class + with an escaped 'f' outside a character class does not register an offense - with an escaped 'a' inside a character class + with an escaped 'S' outside a character class does not register an offense - with an escaped 'p{alpha}' inside a character class + with an escaped 'Z' outside a character class does not register an offense - with an escaped character class and following escaped char + with an escaped 'J' outside a character class does not register an offense - with an escaped 'H' inside a character class + with an escaped 'j' inside a character class does not register an offense - with an escaped 'P{alpha}' inside a character class + with an escaped 'v' outside a character class does not register an offense - with a POSIX character class then allowed escape inside a character class + with an escaped 'U' outside a character class does not register an offense - with an escaped 'Q' outside a character class + with an escaped 'y' outside a character class does not register an offense - with an escaped 'Y' outside a character class + with an escaped '-' character being the first character inside a character class + registers an offense and corrects + with an escaped 's' outside a character class does not register an offense - with an escaped 'V' inside a character class + with an escaped '.' inside a character class + registers an offense and corrects + with an escaped 'L' outside a character class does not register an offense - with an escaped 'j' inside a character class + with an escaped 'L' inside a character class does not register an offense - with an escaped '+' inside a character class inside a group + with an escaped . inside a character class beginning with : registers an offense and corrects - with an escaped 'Z' inside a character class + with an escaped '^' outside a character class does not register an offense - with an escaped 'S' outside a character class + with an escaped 'q' outside a character class does not register an offense - with an invalid g escape + with an escaped 'T' inside a character class does not register an offense - with an escaped 'G' outside a character class + with an escaped '[' inside a character class does not register an offense - with an escaped 'j' outside a character class + with an escaped 'E' outside a character class does not register an offense - with an escaped 'N' inside a character class + with an escaped 'V' inside a character class does not register an offense - with an escaped 'y' outside a character class + with an escaped 'K' inside a character class does not register an offense - with an escaped 'u{0041}' inside a character class + with escaped slashes does not register an offense - with an escaped 'O' inside a character class + with a backreference does not register an offense - with an escaped 'B' inside a character class + with an escaped interpolation outside a character class does not register an offense - with an escaped 'q' inside a character class + with an escaped 'N' outside a character class does not register an offense - with an escaped 'H' outside a character class + with an escaped 'I' inside a character class does not register an offense - with an escaped 'U' outside a character class + with an escaped 'w' outside a character class does not register an offense - with an escaped '*' inside a character class + with an escaped '}' inside a character class registers an offense and corrects - with an escaped 'C-c' outside a character class + with an escaped 'p{alpha}' inside a character class does not register an offense - with an escaped 'l' inside a character class + with an escaped '?' outside a character class does not register an offense - with an interpolation followed by redundant escapes - registers offenses and corrects - with a line continuation within a character class + with an escaped 'G' inside a character class does not register an offense - with an escaped '#' inside a character class + with an escaped 'y' inside a character class does not register an offense - with a POSIX character class then disallowed escape inside a character class - registers an offense and corrects - with an escaped '-' inside a character class - registers an offense and corrects - with an escaped 'b' inside a character class + with an escaped '[' outside a character class does not register an offense - with an escaped 'S' inside a character class + with an escaped 'e' inside a character class does not register an offense - with an escaped 'I' outside a character class + with an escaped 'D' inside a character class does not register an offense - with an escaped 'cc' outside a character class + with an escaped '(' outside a character class does not register an offense - with an escaped 'd' outside a character class + with an escaped 'e' outside a character class does not register an offense - with an escaped 'K' inside a character class + with an escaped 'w' inside a character class does not register an offense - with an escaped 'J' outside a character class + with an escaped 'H' outside a character class does not register an offense - with an escaped 'i' inside a character class + with an escaped 'q' inside a character class does not register an offense - with an escaped 'o' outside a character class + with an escaped 'm' inside a character class does not register an offense - with an escaped 'R' inside a character class + with an escaped 'i' outside a character class does not register an offense - with an escaped 'cc' inside a character class + with an escaped 'n101' outside a character class does not register an offense - with an escaped '\' outside a character class + with an escaped 'j' outside a character class does not register an offense - with an escaped 'P{alpha}' outside a character class + with an escaped 'i' inside a character class does not register an offense - with an escaped ' ' outside a character class + with an escaped 'o' inside a character class does not register an offense - with an escaped interpolation outside a character class + with an escaped 'p{alpha}' outside a character class does not register an offense - with an escaped '-' character being the first character inside a character class + with an escaped ']' outside a character class + does not register an offense + with an escaped ')' inside a character class registers an offense and corrects - with regexp options and a redundant escape - registers offenses and corrects - with an escaped . inside a character class beginning with : + with an escaped 'u0041' inside a character class + does not register an offense + with an escaped '-' character being the last character inside a character class registers an offense and corrects - with an escaped 'v' inside a character class + with an escaped 'h' inside a character class does not register an offense - with an escaped 'a' outside a character class + with an escaped 'H' inside a character class does not register an offense - with an escape inside an interpolated string + with an escaped 'C-c' inside a character class does not register an offense - with an escaped 'h' inside a character class + with a single-line %r{} regexp + with an escaped { or } outside a character class does not register an offense - with a nested character class containing redundant escape + with redundantly-escaped slashes registers an offense and corrects - with an escaped 'r' outside a character class + with an escaped { or } inside a character class does not register an offense - with an escaped 'F' inside a character class + without escapes does not register an offense - with an escaped 'w' inside a character class + with a single-line %r!! regexp + with escaped delimiters inside a character-class does not register an offense - with an escaped 'Z' outside a character class + without escapes does not register an offense - with an escaped 'w' outside a character class + with escaped delimiters and regexp options does not register an offense - with an escaped 'R' outside a character class + with escaped delimiters outside a character-class does not register an offense - with an escaped 'K' outside a character class + with a single-line %r@@ regexp + with escaped delimiters outside a character-class does not register an offense - with an escaped 'l' outside a character class + with escaped delimiters and regexp options does not register an offense - with an escaped '*' outside a character class + with escaped delimiters inside a character-class does not register an offense - with an escaped 'W' outside a character class + without escapes does not register an offense - with an escaped 'G' inside a character class + with a single-line %r() regexp + with escaped delimiters and regexp options does not register an offense - with an escaped 'A' outside a character class + with escaped delimiters inside a character-class does not register an offense - with an escaped '+' inside a character class - registers an offense and corrects - with an escaped '\' inside a character class + without escapes does not register an offense - with an escaped 'M-a' outside a character class + with escaped delimiters outside a character-class does not register an offense - with an escaped 'Q' inside a character class + with a single-line %r~~ regexp + without escapes does not register an offense - with an escaped 'L' outside a character class + with escaped delimiters and regexp options does not register an offense - with an escaped 'T' inside a character class + with escaped delimiters inside a character-class does not register an offense - with an escaped 'T' outside a character class + with escaped delimiters outside a character-class does not register an offense - with an escaped 'N' outside a character class + with a multi-line %r// regexp + without escapes + does not register an offense + with escaped slashes + does not register an offense + with a single-line %r__ regexp + without escapes does not register an offense - with a single-line %r~~ regexp with escaped delimiters outside a character-class does not register an offense + with escaped delimiters and regexp options + does not register an offense with escaped delimiters inside a character-class does not register an offense - with escaped delimiters and regexp options + with a single-line %r// regexp + without escapes + does not register an offense + with escaped slashes + does not register an offense + with a single-line %r^^ regexp + with escaped delimiters inside a character-class does not register an offense without escapes does not register an offense - with a single-line %r__ regexp with escaped delimiters and regexp options does not register an offense - without escapes + with escaped delimiters outside a character-class does not register an offense + with a single-line %r<> regexp with escaped delimiters outside a character-class does not register an offense + without escapes + does not register an offense with escaped delimiters inside a character-class does not register an offense - with a multi-line %r// regexp - with escaped slashes + with escaped delimiters and regexp options does not register an offense + with a multi-line %r{} regexp without escapes does not register an offense + with a # inside a character class + does not register an offense + with redundantly-escaped slashes + registers an offense and corrects + with a redundant escape after a line with comment + registers an offense and corrects + with multibyte characters + removes the escape character at the right position -RuboCop::Cop::Style::RedundantSelf - does not report an offense when lvasgn name is used in `while` - does not report an offense when lvasgn name is used in `unless` - reports an offense when a different masgn name is used in `if` - does not report an offense when masgn name is used in `while` - does not report an offense when lvasgn name is used in `if` - reports an offense a self receiver on an rvalue - does not report an offense when masgn name is used in `unless` - accepts a self receiver with the square bracket operator - accepts a self receiver with the double less-than operator - does not report an offense when receiver and lvalue have the same name - does not report an offense when self receiver in a method argument and lvalue have the same name - does not report an offense when masgn name is used in `if` - accepts when nested receiver and lvalue have the name name - accepts a self receiver used to distinguish from argument of block - accepts a self receiver for methods named like ruby keywords - does not report an offense when masgn name is used in `until` - accepts a self receiver of methods also defined on `Kernel` - does not report an offense when lvasgn name is nested below `if` - accepts a self receiver on an lvalue of a plus-assignment - accepts a self receiver on an lvalue of an or-assignment - does not report an offense when self receiver in a method argument and multiple assigned lvalue have the same name - accepts a self receiver used to distinguish from constant - reports an offense when a different lvasgn name is used in `if` - accepts a self receiver on an lvalue of an assignment - reports an offense a self receiver of .call - accepts a self receiver on an lvalue of mlhs arguments - does not report an offense when lvasgn name is used in `until` - does not report an offense when receiver and multiple assigned lvalue have the same name - accepts a self receiver on an lvalue of a parallel assignment - accepts a self receiver of .() - accepts a self receiver on an lvalue of an and-assignment - with ruby >= 2.7 - with pattern matching - accepts a self receiver with a `match-alt` - registers an offense when using a self receiver with a pin - registers an offense when using self with a different match var - accepts a self receiver in a conditional pattern - accepts a self receiver in a nested pattern` - accepts a self receiver on an `match-var` - accepts a self receiver on a `array-pattern` - accepts a self receiver on a `hash-pattern` - accepts a self receiver in a `if-guard` - Ruby 2.7 - registers offense for self usage in numblocks - class methods - accepts a self receiver used to distinguish from local variable - accepts a self receiver used to distinguish from optional argument - accepts a self receiver used to distinguish from argument - accepts a self receiver used to distinguish from blockarg - instance methods - accepts a self receiver used to distinguish from an argument when an inner method is defined - accepts a self receiver used to distinguish from an argument - accepts a self receiver used to distinguish from local variable - accepts a self receiver used to distinguish from optional argument - accepts a self receiver used to distinguish from argument - accepts a self receiver used to distinguish from blockarg - -RuboCop::Cop::Style::DefWithParentheses - accepts def without arguments - reports an offense for def with empty parens - reports an offense for class def with empty parens - accepts def with arg and parens - accepts empty parentheses in one liners - Ruby >= 3.0 - reports an offense for endless method definition with empty parens - -RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks - when there are multiple parameters on the first line - registers an offense and corrects starting from the 2nd argument - when parameter's default value starts on same line but ends on different line - registers an offense and corrects - when second parameter starts on same line as end of first - registers an offense and corrects - when there are no parameters - does not add any offenses - when many parameter are on multiple lines, two on same line - registers an offense and corrects - when one parameter on same line - does not add any offenses - when two parameters are on next line - does not add any offenses - when many parameters are on multiple lines, three on same line - registers an offense and corrects - when many parameters including hash are on multiple lines, three on same line - registers an offense and corrects +RuboCop::DirectiveComment + #single_line? + when does NOT relate to single line + is expected to equal false + when relates to single line + is expected to equal true + #cop_names + when couple departments specified + is expected to eq ["Foo/Bar", "Foo/Baz", "Baz/Bar"] + when only cop specified + is expected to eq ["Foo/Bar"] + when department and cops specified + is expected to eq ["Foo/Bar", "Foo/Baz", "Baz/Cop"] + when redundant directive cop department specified + is expected to eq ["Lint/One", "Lint/Two"] + when all cops mentioned + is expected to eq ["all_names"] + when only department specified + is expected to eq ["Foo/Bar", "Foo/Baz"] + #directive_count + when cops and departments used + is expected to eq 4 + when few department used + is expected to eq 3 + when few cops used + is expected to eq 2 + #disabled? + when enable + is expected to equal false + when disable + is expected to equal true + when todo + is expected to equal true + #department_names + when only cop specified + is expected to eq [] + when all cops mentioned + is expected to eq [] + when department and cops specified + is expected to eq ["Foo"] + when only department specified + is expected to eq ["Foo"] + when couple departments specified + is expected to eq ["Foo", "Baz"] + #match_captures + when disable + is expected to eq ["disable", "all", nil, nil] + when todo + is expected to eq ["todo", "all", nil, nil] + when typo + is expected to be nil + when enable + is expected to eq ["enable", "Foo/Bar", nil, "Foo/"] + #match? + when cop names are same as in the comment + is expected to equal true + when there are no cop names + is expected to equal false + when cop names are same but in a different order + is expected to equal true + when disabled all cops + is expected to equal true + when cop names are superset of names + is expected to equal false + when cop names are subset of names + is expected to equal false + when cop names are same but have duplicated names + is expected to equal true + #in_directive_department? + when cop disabled + is expected to equal false + when cop department disabled + is expected to equal true + when another department disabled + is expected to equal false + #line_number + returns line number for directive + #enabled? + when enable + is expected to equal true + when todo + is expected to equal false + when disable + is expected to equal false + #overridden_by_department? + when there are no cops + is expected to equal false + when there are no departments + is expected to equal false + when cop is overridden by it's department + is expected to equal true + when cop is not overridden by it's department + is expected to equal false + .before_comment + when line has NO code + is expected to eq "" + when line has code + is expected to eq "def foo " + #disabled_all? + when disabled all cops + is expected to equal true + when enabled specific cops + is expected to equal false + when disabled specific cops + is expected to equal false + when enabled all cops + is expected to equal false + #enabled_all? + when enabled all cops + is expected to equal true + when enabled specific cops + is expected to equal false + when disabled all cops + is expected to equal false + when disabled specific cops + is expected to equal false + #all_cops? + when mentioned specific cops + is expected to equal false + when mentioned all + is expected to equal true -RuboCop::Cop::Lint::ImplicitStringConcatenation - when the string literals contain newlines - registers an offense - does not register an offense for a single string - on adjacent string literals on different lines - does not register an offense - on a string with interpolations - does register an offense - on adjacent string literals on the same line - registers an offense - when in a method call's argument list - notes that the strings could be separated by a comma instead - on a single string literal - does not register an offense - when inside an array - notes that the strings could be separated by a comma instead +RuboCop::Cop::Layout::SpaceAroundMethodCallOperator + does not register an offense when using `__ENCODING__` + does not register an offense when no method call operator + safe navigation operator + registers an offense and corrects when space after last method call operator + registers an offense and corrects when space before method call + registers an offense and corrects when spaces around method call + registers an offense and corrects when space after method call + registers an offense and corrects when space before last method call operator + registers an offense and corrects when space before first method call operator + registers an offense and corrects when space around multiple method call operator + does not register an offense when no space around any `.` operators + registers an offense and corrects when space after first method call operator + registers an offense and corrects when spaces after method call + registers an offense and corrects when space around intermediate method call operator + registers an offense and corrects when spaces before method call + does not register an offense when no space around method call + when multi line method call + registers an offense and corrects when space before method call + does not register an offense when no space after the `&.` + registers an offense and corrects when space before method call in suffix chaining + :: operator + does not register an offense when no space around any `.` operators + registers an offense and corrects when space after last method call operator + registers an offense and corrects when space around intermediate method call operator + does not register an offense if no space before `::` operator with inheritance + registers an offense and corrects when space around multiple method call operator + registers an offense and corrects when space after first operator with assignment + registers an offense and corrects when multiple spaces with assignment + registers an offense and corrects when space after method call + does not register an offense if no space before `::` operator with assignment + registers an offense and corrects when spaces after method call + does not register an offense when no space around method call + does not register an offense if no space with conditionals + when multi line method call + registers an offense and corrects when space before method call + does not register an offense when no space after the `::` + dot operator + registers an offense and corrects when spaces after `Proc#call` shorthand call + registers an offense and corrects when spaces before method call + registers an offense and corrects when space before method call + registers an offense and corrects when space after first method call operator + registers an offense and corrects when space after method call + registers an offense and corrects when spaces after method call + registers an offense and corrects when space around multiple method call operator + does not register an offense when no space around any `.` operators + registers an offense and corrects when space around intermediate method call operator + registers an offense and corrects when space after last method call operator + registers an offense and corrects when space before last method call operator + registers an offense and corrects when spaces around method call + registers an offense and corrects when space before first method call operator + does not register an offense when no space around method call + when multi line method call + registers an offense and corrects when space before method call in suffix chaining + does not register an offense when no space after the `.` + registers an offense and corrects when space before method call + when there is a space between `.` operator and a comment + does not register an offense when there is not a space before `.` + registers an offense when there is a space before `.` -RuboCop::Cop::Style::NestedModifier - adds parentheses to method arguments when needed in autocorrection - does not add redundant parentheses in autocorrection - autocorrects unless + unless - registers one offense for more than two modifiers - autocorrects if + unless - autocorrects unless with a comparison operator + if - adds parentheses when needed in autocorrection - autocorrects unless + if - autocorrects if + if - while - behaves like not correctable - does not autocorrect when while is the outer modifier - does not autocorrect when while is the inner modifier - until - behaves like not correctable - does not autocorrect when until is the outer modifier - does not autocorrect when until is the inner modifier +RuboCop::Cop::Style::GuardClause + registers an offense when using `|| raise` in `then` branch + registers an offense when using `and return` in `then` branch + does not report an offense if body is if..elsif..end + registers an error if non-control-flow branch has multiple lines + doesn't register an error if condition has multiple lines + registers an error if non-control-flow branch has multiple lines + registers an error with break in the if branch + does not report an offense if return is inside if..elsif..else..end + registers an error with return in the if branch + accepts a method with empty parentheses as its body + registers an error with raise "error" in the if branch + registers an error if non-control-flow branch has multiple lines + registers an offense when using `|| raise` in `else` branch + registers an offense when using `and return` in `else` branch + doesn't register an error if control flow expr has multiple lines + doesn't register an error if condition has multiple lines + registers an error with break in the else branch + accepts a method whose body is a modifier if / unless + registers an error with raise "error" in the else branch + does not report an offense if raise "error" is inside if..elsif..else..end + does not register an offense when assigning the result of a guard condition with `else` + registers an error with next in the if branch + does not report an offense if return is inside elsif + doesn't register an error if condition has multiple lines + doesn't register an error if control flow expr has multiple lines + accepts a method which body does not end with if / unless + does not report an offense if next is inside if..elsif..else..end + doesn't register an error if control flow expr has multiple lines + doesn't register an error if condition has multiple lines + does not report an offense if break is inside if..elsif..else..end + registers an error with return in the else branch + registers an error if non-control-flow branch has multiple lines + does not report an offense if raise "error" is inside elsif + does not report an offense if next is inside elsif + does not report an offense if break is inside elsif + doesn't report an offense if condition has multiple lines + doesn't register an error if control flow expr has multiple lines + registers an error with next in the else branch + accepts a method which body is if / unless with else + with Metrics/MaxLineLength enabled + when the correction is too long for a single line + with a nested `begin` node + does registers an offense + with a trivial body + does not register an offense + with a nested `if` node + does registers an offense + behaves like reports offense + reports an offense if method body is if / unless without else + reports an offense if method body ends with if / unless without else + MinBodyLength: 4 + accepts a method whose body has 3 lines + AllowConsecutiveConditionals: false + reports an offense when not allowed same depth multiple if statement andpreceding expression is a conditional at the same depth + method in module + registers an offense for singleton methods + registers an offense for instance method + Invalid MinBodyLength + fails with an error + behaves like reports offense + reports an offense if method body is if / unless without else + reports an offense if method body ends with if / unless without else + MinBodyLength: 1 + reports an offense for if whose body has 1 line + with Metrics/MaxLineLength disabled + registers an offense with modifier example code regardless of length + AllowConsecutiveConditionals: true + reports an offense when allowed same depth multiple if statement andpreceding expression is not a conditional at the same depth + does not register an offense when allowed same depth multiple if statement andpreceding expression is not a conditional at the same depth -RuboCop::Cop::Style::For - when each is the enforced style - accepts multiline each - registers an offense for for - registers an offense for opposite + correct style - registers multiple offenses - accepts def for - accepts :for - autocorrect - corrects an array with `&` operator - corrects an array with `||` operator - corrects an array with `+` operator - corrects an array with `-` operator - corrects to `each` without parenthesize collection if non-operator method called - corrects a tuple of items - corrects an array with `*` operator - changes for that does not have do or semicolon to each - corrects an array with `&&` operator - corrects an array with `|` operator - with range - changes for to each - changes for that does not have do or semicolon to each - without parentheses - changes for to each - changes for that does not have do or semicolon to each - when for is the enforced style - registers multiple offenses - registers an offense for correct + opposite style - accepts for - accepts single line each - registers an offense for multiline each - registers an offense for each without an item and uses _ as the item - registers an offense for a tuple of items +RuboCop::Cop::Style::MethodCallWithArgsParentheses + when inspecting macro methods with IncludedMacros + in a module body + finds offense + behaves like endless methods + endless methods + without arguments + does not register an offense for `defs` when there are arguments + does not register an offense for `defs` when there are parens + does not register an offense when there are no parens + does not register an offense when there are parens + does not register an offense when there are arguments + with arguments + requires method calls to have parens + for a macro in both IncludedMacros and AllowedMethods + allows + for a macro not on the included list + allows + in a class body + finds offense + allowing parens in string interpolation + accepts parens for camel-case method names + when EnforcedStyle is require_parentheses (default) + autocorrects call with multiple args by adding braces + autocorrects fully parenthesized args by removing space + autocorrects calls where arg is method call + register an offense for methods starting with capital without parens + autocorrects partially parenthesized args by adding needed braces + register no offense for yield without args + register no offense for superclass call with parens + accepts no parens for unary operators + autocorrects calls where the argument node is a number + register an offense for superclass call without parens + autocorrects calls with multiple args by adding needed braces + register no offense for superclass call without args + autocorrects calls where the argument node is a constant + accepts no parens for operators + accepts no parens for setter methods + register an offense for method call without parens + register an offense for yield without parens + autocorrects parenthesized args for local methods by removing space + accepts no parens in method call without args + accepts parens in method call with args + autocorrects calls where multiple args are method calls + register an offense for non-receiver method call without parens + accepts parens in method call with do-end blocks + when inspecting macro methods + in a class body + does not register an offense + in a module body + does not register an offense + AllowedPatterns + ignored methods listed in AllowedPatterns + with AllowedMethods + allow method listed in AllowedMethods + behaves like endless methods + endless methods + without arguments + does not register an offense for `defs` when there are arguments + does not register an offense when there are arguments + does not register an offense when there are no parens + does not register an offense when there are parens + does not register an offense for `defs` when there are parens + with arguments + requires method calls to have parens when using safe navigation operator - does not break - Ruby 2.7 - registers an offense for each without an item and uses _ as the item + register an offense for method call without parens + when EnforcedStyle is omit_parentheses + register an offense for parens in do-end blocks + accepts no parens in method call without args + accepts parens in block passing calls + accepts parens in chained method calls + accepts parens in calls with args with logical operators + accepts parens in implicit #to_proc + register an offense for parens in method call without args + accepts parens in super calls with braced blocks + register an offense in complex conditionals + accepts parens in chaining with safe operators + accepts parens in calls with logical operators + accepts parens in calls with hash as arg + accepts parens in method args + register an offense for parens in the last chain + register an offense for hashes in keyword values + register an offense for superclass call with parens + accepts parens in blocks with braces + accepts parens in super method calls as arguments + accepts parens in args splat + register an offense for multi-line method calls + accepts parens in single-line inheritance + autocorrects multi-line calls with trailing whitespace + accepts parens in argument calls with braced blocks + accepts parens in operator method calls + accepts parens in literals with unary operators as first argument + accepts parens in default argument value calls + register an offense for %r regex literal as arguments + register an offense in multi-line inheritance + autocorrects single-line calls + register an offense for yield call with parens + accepts parens in default keyword argument value calls + accepts parens in assignment in conditions + autocorrects complex multi-line calls + accepts parens in args with ternary conditions + accepts parens in camel case method without args + accepts parens in super without args + accepts parens in nested method args + accepts parens in yield argument method calls + register an offense in assignments + accepts parens in chaining with operators + accepts parens in range literals + register an offense for camel-case methods with arguments + accepts special lambda call syntax + accepts parens in slash regexp literal as argument + register an offense for parens in string interpolation + accepts parens in ternary condition calls + accepts parens in splat calls + accepts no parens in method call with args + allowing parenthesis in chaining + register offense for single-line chaining without previous parens + register offense for multi-line chaining without previous parens + accepts parens in the last call if any previous calls with parentheses + accepts no parens in the last call if previous calls with parens + forwarded arguments in 2.7 + accepts parens for forwarded arguments + behaves like endless methods + endless methods + with arguments + requires method calls to have parens + without arguments + registers an offense for `defs` when there are parens + does not register an offense when there are arguments + registers an offense when there are parens + does not register an offense when there are no parens + does not register an offense for `defs` when there are arguments + allowing parens in camel-case methods + accepts parens for camel-case method names + allowing parens in multi-line calls + accepts parens for multi-line calls + numbered parameters in 2.7 + accepts parens for braced numeric block calls + forwarded arguments in 3.0 + accepts parens for forwarded arguments + hash value omission in 3.1 + registers an offense when last argument is a hash value omission + does not register an offense when hash value omission with parentheses and using modifier form + registers an offense when with parentheses call expr follows + registers and corrects an offense when explicit hash value with parentheses and using modifier form + registers an offense using assignment with parentheses call expr follows + does not register an offense when without parentheses call expr follows -RuboCop::Cop::Style::TernaryParentheses - when configured to enforce parentheses omission - accepts condition including a range - with no space between the parentheses and question mark - registers an offense - with one line pattern matching - does not register an offense - with an unparenthesized method call condition - registers an offense for defined check - registers an offense when calling method with a parameter - when calling method on a constant receiver - registers an offense - when calling method on a literal receiver - registers an offense - when calling method with multiple arguments - registers an offense - when calling method on a receiver - registers an offense - with a simple condition - registers an offense for yield in condition - registers an offense for query method in condition - accepts multi-line boolean expression starting on following line - registers an offense for multi-line boolean expression - registers an offense for accessor in condition - with a complex condition - registers an offense for query method on object - registers an offense for equality check - registers an offense for arithmetic expression - registers an offense for defined with variable in condition - registers an offense for defined with nested constant in condition - registers an offense for negated condition - registers an offense for boolean expression using keyword - registers an offense for defined with class method in condition - registers an offense for defined with method chain in condition - accepts parens around inner boolean expression - registers an offense for boolean expression - with an assignment condition - accepts double safe assignment - accepts safe assignment as part of multiple assignment - registers an offense for equality check - accepts safe assignment - behaves like safe assignment disabled - registers an offense for parens around outer assignment - registers an offense for parens around assignment - registers an offense for parens around inner assignment - with one line pattern matching - does not register an offense - configured for parentheses on complex and there are no parens - with an assignment condition - accepts safe assignment - registers an offense for equality check - with complex condition - registers an offense for arithmetic and equality check - registers an offense for comparison with method call on receiver - registers an offense for compound boolean expression - registers an offense for boolean expression with inner parens - registers an offense for boolean expression - registers an offense for subtraction expression - registers an offense for addition expression - registers an offense comparison with exponentiation - registers an offense for comparison - registers an offense for comparison with multiplication - when configured to enforce parentheses inclusion - with a simple condition - registers an offense for query method in condition - registers an offense for accessor in condition - registers an offense for yield in condition - with an assignment condition - registers an offense for double assignment with equality check in condition - accepts safe assignment in condition - registers an offense for triple assignment - registers an offense for double assignment - with a complex condition - registers an offense for arithmetic condition - registers an offense for defined? with variable in condition - registers an offense for boolean expression - registers an offense for boolean expression using keyword - registers an offense for defined? with method chain in condition - registers an offense for defined? with nested constant in condition - registers an offense for equality check - registers an offense when calling method on a receiver - registers an offense for negated condition - registers an offense for boolean expression containing parens - registers an offense for defined? with class method in condition - configured for parentheses on complex and there are parens - accepts condition including a range - with an assignment condition - accepts equality check - accepts accepts safe multiple assignment - accepts safe assignment - accepts safe assignment as part of multiple assignment - behaves like safe assignment disabled - registers an offense for parens around outer assignment - registers an offense for parens around inner assignment - registers an offense for parens around assignment - with a complex condition - accepts boolean expression - registers an offense for defined with method chain in condition - registers an offense for defined with class method in condition - registers an offense for defined with variable in condition - registers an offense when calling method on a receiver - accepts boolean expression using keywords - registers an offense for defined with nested constant in condition - with a simple condition - registers an offense for yield in condition - registers an offense for save navigation - registers an offense for accessor in condition - registers an offense for query method in condition - registers an offense with preceding boolean keyword expression - with method call condition - registers an offense when calling method with a parameter - registers an offense for defined check - registers an offense when calling method on a receiver - without accessor in method call parameters - registers an offense for array include? with parens - registers an offense for array include? without parens - with accessor in method call parameters - registers an offense for array include? with multiple parameters without parens - registers an offense for array include? with multiple parameters with parens - registers an offense for array include? without parens +RuboCop::Cop::Layout::SpaceInsideParens + when EnforcedStyle is space + accepts parentheses with line break + registers an offense in block parameter list with no spaces + accepts parentheses with comment and line break + accepts empty parentheses without spaces + accepts parentheses with spaces + registers an offense for no spaces inside parens + registers an offense for no space around heredoc start + registers an offense for space inside empty parens + when EnforcedStyle is compact + accepts parentheses with spaces + registers an offense for no space around heredoc start + registers an offense for space inside empty parens + accepts three consecutive left parentheses + registers an offense for no spaces inside parens + registers multiple offense for a missing and extra space between consecutive brackets + accepts three consecutive right parentheses + accepts two consecutive right parentheses + accepts empty parentheses without spaces + accepts parentheses with comment and line break + registers an offense for space between consecutive brackets + registers an offense in block parameter list with no spaces + accepts two consecutive left parentheses + accepts parentheses with line break + when EnforcedStyle is no_space + registers an offense for spaces inside parens + accepts parentheses with no spaces + accepts parentheses with line break + accepts parentheses in block parameter list + accepts parentheses with comment and line break + registers an offense for space around heredoc start -RuboCop::Cop::Style::AsciiComments - registers an offense for a comment with non-ascii chars - accepts comments with only ascii chars - registers an offense for comments with mixed chars - when certain non-ascii chars are allowed - accepts comment with allowed non-ascii chars - registers an offense for comments with non-allowed non-ascii chars +RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier + EnforcedStyle is `only_before` + registers an offense for missing blank line before public + does not register an offense when `end` immediately after private + registers an offense for missing blank line before protected + registers an offense for missing blank line before private + registers an offense for blank line after private + registers an offense for blank line after protected + does not register an offense when `end` immediately after protected + accepts blank line after module_function + registers an offense for missing blank line before module_function + accepts missing blank line after protected + accepts missing blank line after private + accepts blank line after public + Ruby 2.7 + registers an offense for missing around line before module_function + ignores module_function with numblock argument + registers an offense for missing around line before public + registers an offense for missing around line before private + ignores private with numblock argument + ignores public with numblock argument + ignores protected with numblock argument + registers an offense for missing around line before protected + EnforcedStyle is `around` + requires blank line after module_function + accepts missing blank line when specifying a superclass that breaks the line + ignores module_function with block argument + accepts missing blank line when specifying `self` that breaks the line + accepts missing blank line when at the beginning of file and preceded by a comment + accepts missing blank line when specifying a superclass that breaks the line + accepts missing blank line when at the end of specifying a superclass + ignores comment line before public + accepts missing blank line when at the end of specifying `self` + requires blank line before module_function + requires blank line after private + accepts missing blank line when at the beginning of module + requires blank line after, but not before, module_function when at the beginning of class/module + accepts missing blank line when at the end of specifying `self` + requires blank line when next line started with end + ignores protected with block argument + ignores module_function deep inside a method call + ignores private deep inside a method call + accepts missing blank line when at the beginning of class + accepts missing blank line when at the end of block + accepts missing blank line when at the beginning of class + recognizes blank lines with DOS style line endings + requires blank line when next line started with end + accepts missing blank line when at the beginning of module + accepts only using access modifier + autocorrects blank line after #{access_modifier} with comment + ignores private with block argument + accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line + requires blank line after, but not before, private when at the beginning of class/module + requires blank line before protected + ignores comment line before module_function + requires blank line after protected + accepts missing blank line when at the beginning of module + recognizes blank lines with DOS style line endings + recognizes blank lines with DOS style line endings + accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line + accepts missing blank line when at the end of specifying a superclass + accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line + ignores public with block argument + accepts missing blank line when at the beginning of file and preceded by a comment + accepts missing blank line when at the end of specifying a superclass + autocorrects blank line after #{access_modifier} with comment + ignores public with a right-hand-side condition + requires blank line when next line started with end + accepts only using access modifier + ignores protected inside a method call + accepts missing blank line when specifying a superclass that breaks the line + accepts missing blank line when specifying `self` that breaks the line + ignores module_function with a right-hand-side condition + accepts missing blank line when at the beginning of class + requires blank line after, but not before, protected when at the beginning of class/module + accepts only using access modifier + accepts missing blank line when at the end of block + accepts only using access modifier + accepts missing blank line when at the end of specifying `self` + ignores private with a right-hand-side condition + ignores an accessor with the same name as module_function above a method definition + requires blank line before public + accepts missing blank line when specifying a superclass that breaks the line + accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line + ignores comment line before protected + accepts missing blank line when at the beginning of sclass + autocorrects blank line after #{access_modifier} with comment + accepts missing blank line when at the beginning of file and preceded by a comment + accepts missing blank line when at the end of block + accepts missing blank line when at the end of block + accepts missing blank line when at the beginning of sclass + ignores comment line before private + ignores protected with a right-hand-side condition + autocorrects blank line after #{access_modifier} with comment + accepts missing blank line when specifying `self` that breaks the line + requires blank line before private + ignores an accessor with the same name as public above a method definition + requires blank line after public + accepts missing blank line when at the beginning of sclass + requires blank line when next line started with end + ignores public deep inside a method call + ignores module_function inside a method call + accepts missing blank line when at the end of specifying `self` + accepts missing blank line when at the beginning of class + recognizes blank lines with DOS style line endings + accepts missing blank line when at the beginning of sclass + ignores an accessor with the same name as private above a method definition + accepts missing blank line when at the beginning of module + accepts missing blank line when specifying `self` that breaks the line + accepts missing blank line when at the beginning of file and preceded by a comment + ignores protected deep inside a method call + ignores an accessor with the same name as protected above a method definition + requires blank line after, but not before, public when at the beginning of class/module + ignores public inside a method call + accepts missing blank line when at the end of specifying a superclass + ignores private inside a method call + at the beginning of block + for blocks defined with {} + accepts missing blank line + accepts missing blank line with arguments + for blocks defined with do + accepts missing blank line with arguments + requires blank line after, but not before, protected + accepts missing blank line + at the beginning of block + for blocks defined with do + accepts missing blank line with arguments + accepts missing blank line + requires blank line after, but not before, public + for blocks defined with {} + accepts missing blank line + accepts missing blank line with arguments + at the beginning of block + for blocks defined with do + accepts missing blank line + requires blank line after, but not before, module_function + accepts missing blank line with arguments + for blocks defined with {} + accepts missing blank line with arguments + accepts missing blank line + at the beginning of block + for blocks defined with {} + accepts missing blank line + accepts missing blank line with arguments + for blocks defined with do + accepts missing blank line with arguments + requires blank line after, but not before, private + accepts missing blank line -RuboCop::Cop::InternalAffairs::OffenseLocationKeyword - does not register an offense when the `loc` is on a child node - does not register an offense when the `loc` is on a different node - when `node.loc.selector` is passed - registers an offense - registers an offense if message argument is passed +RuboCop::Cop::Lint::RequireRangeParentheses + does not register an offense when the end of the range (`..`) is line break and is enclosed in parentheses + registers an offense when the end of the range (`...`) is line break + does not register an offense when begin and end of the range are on the same line + does not register an offense when using `nil..42` + does not register an offense when using `42..nil` + registers an offense when the end of the range (`..`) is line break + Ruby >= 2.7 + does not register an offense when using beginless range only + Ruby >= 2.6 + does not register an offense when using endless range only -RuboCop::Cop::Naming::BinaryOperatorParameterName - does not register an offense for multibyte character method name - does not register an offense for [] - does not register an offense for === - registers an offense and corrects for `#+` when argument is not named other - does not register an offense for []= - does not register an offense for non binary operators - registers an offense and corrects when argument is referenced in method body - does not register an offense for << - registers an offense and corrects for `#equal?` when argument is not named other - works properly even if the argument not surrounded with braces - does not register an offense for the match operator - registers an offense and corrects when assigned to argument in method body - does not register an offense for arg named other - does not register an offense for arg named _other - registers an offense and corrects for `#eql?` when argument is not named other +RuboCop::Cop::InternalAffairs::UselessMessageAssertion + does not register an offense for an assertion about the message + registers an offense for described_class::MSG in let + registers an offense for specs that assert using the MSG + registers an offense for specs that expect offense using the MSG -RuboCop::Cop::Style::RescueStandardError - implicit - accepts rescue modifier - when rescuing in a method definition - accepts rescuing no error class - accepts rescuing StandardError with other errors - accepts rescuing a single error other than StandardError, assigned to a variable - accepts rescuing no error class, assigned to a variable - accepts rescuing StandardError with other errors, assigned to a variable - accepts rescuing a single error other than StandardError - when rescuing StandardError by itself - registers an offense - when the error is assigned to a variable - registers an offense - when rescuing in a begin block - accepts rescuing no error class - accepts rescuing a single error class other than StandardError, assigned to a variable - accepts rescuing StandardError with other errors, assigned to a variable - accepts rescuing ::StandardError with other errors - accepts rescuing StandardError with other errors - accepts rescuing a single error class other than StandardError - accepts rescuing no error class, assigned to a variable - when rescuing StandardError by itself - registers an offense - with ::StandardError - registers an offense - when the error is assigned to a variable - registers an offense - with ::StandardError - registers an offense - explicit - accepts rescue modifier - when rescuing in a begin block - accepts rescuing StandardError by itself - accepts rescuing StandardError by itself, assigned to a variable - accepts rescuing StandardError with other errors, assigned to a variable - accepts rescuing StandardError with other errors - accepts rescuing a single error other than StandardError - accepts rescuing a single error other than StandardErrorassigned to a variable - when calling rescue without an error class - registers an offense - when the error is assigned to a variable - registers an offense - when rescuing in a method definition - accepts rescuing StandardError with other errors - accepts rescuing a single error other than StandardError - accepts rescuing StandardError with other errors, assigned to a variable - accepts rescuing StandardError by itself, assigned to a variable - accepts rescuing StandardError by itself - accepts rescuing a single error other than StandardError, assigned to a variable - when rescue is called without an error class - registers an offense - when the error is assigned to a variable - registers an offense +RuboCop::Cop::Style::SingleLineMethods + autocorrects defs with parentheses after method name + registers an offense for a single-line method and method body is enclosed in parentheses + registers an offense for a single-line method + autocorrects def with semicolon after method name + autocorrects def with argument and no parentheses + autocorrects def with semicolon before end + accepts a multi-line method + autocorrects def with argument in parentheses + does not crash on an method with a capitalized name + endless methods + does not register an offense + when `Style/EndlessMethod` is disabled + corrects to an normal method + when AllowIfMethodIsEmpty is disabled + registers an offense for an empty method + when AllowIfMethodIsEmpty is enabled + accepts a single-line empty method + when `Style/EndlessMethod` is enabled + with `disallow` style + corrects to an normal method + with `allow_single_line` style + behaves like convert to endless method + corrects to an endless method definition when single line method call with parentheses + corrects to an endless method definition when method body is a literal + corrects to an endless class method definition when using > + does not to an endless class method definition when using `next` + corrects to a normal method if the method body contains multiple statements + corrects to an endless class method definition when using == + corrects to an endless class method definition when using === + does not to an endless class method definition when using `break` + handles arguments properly + corrects to an endless class method definition when using < + corrects to an endless method definition when single line method call without parentheses + does not add parens if they are already present + corrects to an endless class method definition + corrects to multiline method definition when defining setter method + corrects to an endless method definition + corrects to an endless class method definition when using <= + retains comments + corrects to an endless class method definition when using >= + corrects to an endless class method definition when using != + does not to an endless class method definition when using `return` + with AllowIfMethodIsEmpty: false + does not turn a method with no body into an endless method + with AllowIfMethodIsEmpty: true + does not correct + with `allow_always` style + behaves like convert to endless method + retains comments + handles arguments properly + corrects to an endless class method definition when using == + corrects to a normal method if the method body contains multiple statements + corrects to an endless method definition when method body is a literal + corrects to an endless class method definition when using < + corrects to an endless method definition + corrects to multiline method definition when defining setter method + does not add parens if they are already present + corrects to an endless class method definition when using >= + corrects to an endless class method definition when using === + corrects to an endless class method definition when using <= + corrects to an endless method definition when single line method call without parentheses + does not to an endless class method definition when using `break` + does not to an endless class method definition when using `return` + corrects to an endless method definition when single line method call with parentheses + corrects to an endless class method definition + corrects to an endless class method definition when using > + does not to an endless class method definition when using `next` + corrects to an endless class method definition when using != + with AllowIfMethodIsEmpty: false + does not turn a method with no body into an endless method + with AllowIfMethodIsEmpty: true + does not correct + prior to ruby 3.0 + corrects to a multiline method -RuboCop::Cop::VariableForce::Reference - .new - when non variable reference node is passed - raises error +RuboCop::FeatureLoader + .load + with unloadable namespaced feature + raises LoadError with preferred message + with dot-prefixed loadable feature + loads it as relative path + with dot-prefixed namespaced feature + loads it as namespaced feature + with normally loadable feature + loads it normally + with namespaced feature + loads it as namespaced feature + with unexpected LoadError from require + raises LoadError RuboCop::Cop::Layout::MultilineArrayBraceLayout - ignores implicit arrays ignores single-line arrays + ignores implicit arrays ignores empty arrays - when comment present before closing brace - corrects closing brace without crashing behaves like multiline literal brace layout same_line style opening brace on same line as first element - autocorrects closing brace on different line as last element - allows closing brace on same line as multi-line element detects closing brace on different line from multiline element allows closing brace on same line from last element + autocorrects closing brace on different line as last element + allows closing brace on same line as multi-line element with a chained call on the closing brace - and a comment after the last element - detects closing brace on separate line from last elementbut does not autocorrect the closing brace but no comment after the last element autocorrects the closing brace + and a comment after the last element + detects closing brace on separate line from last elementbut does not autocorrect the closing brace opening brace on separate line from first element - allows closing brace on same line as last element - detects closing brace on different line from last element allows closing brace on same line as last multiline element + detects closing brace on different line from last element + allows closing brace on same line as last element new_line style + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last multiline element + allows closing brace on separate line from last element opening brace on same line as first element detects closing brace on same line as last multiline element allows closing brace on different line from last element - autocorrects closing brace on same line as last element allows closing brace on different line from multi-line element - opening brace on separate line from first element - allows closing brace on separate line from last element - allows closing brace on separate line from last multiline element - detects closing brace on same line as last element + autocorrects closing brace on same line as last element heredoc - ignores heredocs that could share a last line detects heredoc structures that are safe to add to + ignores heredocs that could share a last line symmetrical style - opening brace on separate line from first element - allows closing brace on separate line from last element - detects closing brace on same line as last element - allows closing brace on separate line from last multiline element opening brace on same line as first element + allows closing brace on same line as last element allows closing brace on same line as last multiline element autocorrects closing brace on different line from last element - allows closing brace on same line as last element detects closing brace on different line from last element with a chained call on the closing brace but no comment after the last element autocorrects the closing brace and a comment after the last element detects closing brace on separate line from last elementbut does not autocorrect the closing brace + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last multiline element + allows closing brace on separate line from last element + when comment present before closing brace + corrects closing brace without crashing behaves like multiline literal brace layout trailing comma - same_line style - opening brace on same line as first element - last element has a trailing comma - autocorrects closing brace on different line as last element symmetrical style opening brace on same line as first element last element has a trailing comma autocorrects closing brace on different line from last element + same_line style + opening brace on same line as first element + last element has a trailing comma + autocorrects closing brace on different line as last element behaves like multiline literal brace layout method argument when arguments to a method - and a comment after the last element - detects closing brace on separate line from last element but no comment after the last element autocorrects the closing brace + and a comment after the last element + detects closing brace on separate line from last element -RuboCop::Cop::Style::MethodDefParentheses - require_parentheses - accepts def with no args and no parens - reports an offense for class def with parameters but no parens - reports an offense for correct + opposite - auto-adds required parens for a defs - auto-adds required parens to argument lists on multiple lines - auto-adds required parens for a defs after a passing method - reports an offense for def with parameters but no parens - behaves like endless methods - endless methods - accepts parens with args - accepts parens without args - accepts parens for method calls inside an endless method - accepts parens with `forward-arg` - require_no_parentheses_except_multiline - when args span multiple lines - auto-adds required parens to argument lists on multiple lines - reports an offense for correct + opposite - behaves like endless methods - endless methods - accepts parens for method calls inside an endless method - accepts parens without args - accepts parens with `forward-arg` - accepts parens with args - when args are all on a single line - behaves like no parentheses - reports an offense for def with no args and parens - accepts def with no args and no parens - reports an offense for def with parameters with parens - reports an offense for opposite + correct - requires parens for forwarding - accepts a class def with parameters with parens - reports an offense for class def with parameters with parens - auto-removes the parens for defs - accepts a def with parameters but no parens - requires parens for anonymous block forwarding - require_no_parentheses - behaves like endless methods - endless methods - accepts parens for method calls inside an endless method - accepts parens with `forward-arg` - accepts parens without args - accepts parens with args - behaves like no parentheses - accepts a class def with parameters with parens - auto-removes the parens for defs - reports an offense for def with no args and parens - reports an offense for class def with parameters with parens - requires parens for forwarding - accepts a def with parameters but no parens - requires parens for anonymous block forwarding - reports an offense for opposite + correct - accepts def with no args and no parens - reports an offense for def with parameters with parens - -RuboCop::Cop::Lint::UselessSetterCall - accepts exception assignments without exploding - is not confused by operators ending with = - with singleton method ending with setter call on local object - registers an offense and corrects - when a lvar does not contain any object passed as argument by binary-operator-assignment at the end of the method - registers an offense and corrects - when a lvar contains a local object instantiated with literal - registers an offense and corrects for the setter call on the lvar - when a lvar declared as an argument is no longer the passed object at the end of the method - registers an offense and corrects for the setter call on the lvar - when a lvar contains an object passed as argument by multiple-assignment at the end of the method - accepts the setter call on the lvar - when a lvar possibly contains an object passed as argument by logical-operator-assignment at the end of the method - accepts the setter call on the lvar - when a lvar contains a non-local object returned by a method - accepts - with method ending with ivar assignment +RuboCop::Cop::Migration::DepartmentName + when a disable comment contains a plain comment accepts - when a lvar contains an object passed as argument at the end of the method - accepts the setter call on the lvar - with method ending with setter call on argument + when todo/enable comments have cop names without departments + registers offenses and corrects when there is space around `:` + registers offenses and corrects + registers offenses and corrects when using a legacy cop name + when a disable comment contains an unexpected character for department name accepts - with method ending with setter call on ivar + when only department name has given + does not register an offense + when a disable comment has cop names with departments accepts - with method ending with square bracket setter on local object - registers an offense and corrects - when a lvar does not contain any object passed as argument with multiple-assignment at the end of the method - registers an offense and corrects - with method ending with setter call on local object - registers an offense and corrects + when an unexpected disable comment format + does not register an offense -RuboCop::Cop::Layout::SpaceAfterMethodName - accepts a defs without arguments - accepts a def with arguments but no parentheses - registers an offense and corrects def with space before the parenthesis - accepts an assignment def with arguments but no parentheses - accepts class method def with arguments but no parentheses - registers offense and corrects class def with space before parenthesis - registers offense and corrects assignment def with space before parenthesis - accepts a def without arguments +RuboCop::Cop::Lint::NextWithoutAccumulator + given an unrelated block + accepts a bare next + accepts next with a value + behaves like reduce/inject + given a reduce block + accepts next within a nested block + accepts next with a value + registers an offense for a bare next + Ruby 2.7 + registers an offense for a bare next + behaves like reduce/inject + given a inject block + registers an offense for a bare next + accepts next within a nested block + accepts next with a value + Ruby 2.7 + registers an offense for a bare next -RuboCop::Cop::Style::QuotedSymbols - configured with `single_quotes` - behaves like enforce single quotes - accepts double quotes with single quotes - accepts double quotes when interpolating a class variable - registers an offense and corrects escape characters properly - accepts unquoted symbols - accepts single quoted symbol with an escaped quote - accepts double quotes with line breaks - accepts single quotes with line breaks - accepts double quotes with interpolation - accepts double quotes when interpolating an instance variable - accepts single quotes with double quotes - accepts double quotes when interpolating a global variable - accepts double quotes when control characters are used - accepts single quotes - registers an offense and corrects for an escaped quote within double quotes - registers an offense and corrects for double quotes in hash keys - accepts double quotes with some other special symbols - registers an offense and corrects for double quotes without interpolation - accepts double quotes when unicode control sequence is used - accepts double quotes with escape sequences - hash with hashrocket style - corrects wrong quotes - accepts properly quoted symbols - configured with `double_quotes` - behaves like enforce double quotes - accepts double quotes with escape sequences - accepts double quotes with interpolation - accepts single quotes with line breaks - accepts double quoted symbol with an escaped quote - accepts unquoted symbols - registers an offense for single quotes - registers an offense and corrects for an escaped quote within single quotes - registers an offense and corrects escape characters properly - accepts double quotes with line breaks - accepts single quotes with double quotes - accepts double quotes - accepts double quotes with single quotes - accepts double quotes when interpolating a class variable - accepts double quotes when interpolating an instance variable - accepts double quotes when interpolating a global variable - hash with hashrocket style - accepts properly quoted symbols - corrects wrong quotes - configured with `same_as_string_literals` - when Style/StringLiterals is configured with double_quotes - behaves like enforce double quotes - accepts double quotes - accepts double quotes when interpolating a class variable - registers an offense and corrects for an escaped quote within single quotes - accepts double quotes with line breaks - accepts unquoted symbols - accepts double quotes when interpolating an instance variable - accepts double quotes when interpolating a global variable - accepts double quotes with escape sequences - registers an offense for single quotes - accepts single quotes with double quotes - accepts single quotes with line breaks - accepts double quotes with interpolation - accepts double quotes with single quotes - registers an offense and corrects escape characters properly - accepts double quoted symbol with an escaped quote - hash with hashrocket style - accepts properly quoted symbols - corrects wrong quotes - when Style/StringLiterals is disabled - behaves like enforce single quotes - accepts single quotes with double quotes - accepts double quotes when interpolating a global variable - accepts single quoted symbol with an escaped quote - registers an offense and corrects for double quotes without interpolation - accepts double quotes with single quotes - accepts unquoted symbols - accepts double quotes when interpolating an instance variable - registers an offense and corrects for double quotes in hash keys - accepts single quotes - accepts double quotes with interpolation - accepts double quotes with escape sequences - accepts double quotes with line breaks - accepts double quotes when control characters are used - accepts double quotes when unicode control sequence is used - accepts double quotes when interpolating a class variable - registers an offense and corrects for an escaped quote within double quotes - accepts single quotes with line breaks - registers an offense and corrects escape characters properly - accepts double quotes with some other special symbols - hash with hashrocket style - accepts properly quoted symbols - corrects wrong quotes - when Style/StringLiterals is configured with single_quotes - behaves like enforce single quotes - accepts single quoted symbol with an escaped quote - accepts double quotes with interpolation - accepts double quotes with single quotes - registers an offense and corrects escape characters properly - accepts single quotes with line breaks - accepts double quotes with some other special symbols - accepts double quotes with escape sequences - registers an offense and corrects for double quotes in hash keys - accepts double quotes when interpolating a class variable - accepts single quotes - accepts double quotes when control characters are used - accepts unquoted symbols - accepts single quotes with double quotes - accepts double quotes when interpolating an instance variable - accepts double quotes when interpolating a global variable - registers an offense and corrects for double quotes without interpolation - accepts double quotes when unicode control sequence is used - accepts double quotes with line breaks - registers an offense and corrects for an escaped quote within double quotes - hash with hashrocket style - accepts properly quoted symbols - corrects wrong quotes - -RuboCop::Cop::Style::LambdaCall - when style is set to call - registers an offense for correct + multiple opposite styles - registers an offense for correct + opposite - registers an offense for x.() - when style is set to braces - autocorrects x.call asdf, x123 to x.(asdf, x123) - autocorrects x.call to x.() - registers an offense for correct + multiple opposite styles - accepts a call without receiver - registers an offense for x.call() - registers an offense for opposite + correct - -RuboCop::Cop::Style::NonNilCheck - when `EnforcedStyle: comparison` of `Style/NilComparison` cop - `IncludeSemanticChanges: false` - does not register an offense for `foo != nil` - `IncludeSemanticChanges: true` - registers an offense for `foo != nil` - when not allowing semantic changes - registers an offense but does not correct when the code was not modified - does not register an offense for != 0 - does not register an offense for not x.nil? - does not register an offense if only expression in class predicate - does not register an offense if only expression in predicate - does not register an offense if last expression in class predicate - does not register an offense with implicit receiver - registers an offense for != nil - does not register an offense for !x.nil? - does not register an offense if last expression in predicate - when allowing semantic changes - does not blow up when autocorrecting implicit receiver - autocorrects by changing `x != nil` to `x` - registers an offense for `not x.nil?` - registers an offense for unless x.nil? - registers an offense for `!x.nil?` - does not register an offense for `x.nil?` - corrects code that would not be modified if IncludeSemanticChanges were false - does not blow up with ternary operators - does not register an offense for `!x` - -RuboCop::Cop::Style::RedundantEach - does not register an offense when using only single `each` - registers an offense when using a method starting with `each_` with `each_with_object` - does not register an offense when using `each_with_index` - registers an offense when using `each.each(&:foo)` - does not register an offense when using `each {}.each_with_index {}` - does not register an offense when using `each_ancestor.each` - does not register an offense when using `each_foo {}.each_with_object([]) {}` - does not register an offense when not chaining `each_` calls - registers an offense when using `each.reverse_each` - does not register an offense when using `each.with_index` - does not register an offense when using `each {}.each_with_object([]) {}` - does not register an offense when using `each_with_index.reverse_each` - does not register an offense when using `each {}.reverse_each {}` - does not register an offense when using `each.with_object` - does not register an offense when using `each` with a symbol proc for last argument - registers an offense when using `reverse_each.each_with_index` - registers an offense when using `each.each_with_index` - registers an offense when using a method starting with `each_` with `each_with_index` - does not register an offense when using `reverse_each {}.each {}` - does not register an offense when using `each` with a symbol proc argument - does not register an offense when using `each_with_object` - does not register an offense when using `reverse_each(&:foo).each {...}` - does not register an offense when using `each` as enumerator - registers an offense when using `each.each` - registers an offense when using `each.each_with_object` - does not register an offense when any method is used between methods with `each` in the method name - registers an offense when using `reverse_each.each_with_object` - registers an offense when using `reverse_each.each` - -RuboCop::Cop::Lint::ReturnInVoidContext - when return is in top scope - accepts - with an initialize method containing a return with a value - registers an offense - with a non initialize method containing a return - accepts - with an initialize method containing a return without a value - accepts - with a setter method containing a return with a value - registers an offense - with a class method called initialize containing a return - accepts - with a setter method containing a return without a value - accepts - -RuboCop::Cop::Lint::RedundantCopEnableDirective - registers correct offense when combined with necessary enable, no white-space after comma - registers an offense and corrects when the first cop is unnecessarily enabled - registers offense and corrects unnecessary enable - registers offense and corrects redundant enabling of same cop - registers correct offense when combined with necessary enable - registers multiple offenses and corrects the same comment - when last cop is unnecessarily enabled - registers an offense and corrects - registers an offense and corrects when there is no space between the cops and the comma - when cop is disabled in the configuration - registers no offense when enabling the cop - registers an offense if enabling it twice - when all department enabled - registers multiple offenses and corrects the same comment - registers an offense and corrects when the first department is unnecessarily enabled - registers correct offense when combined with necessary enable - registers offense and corrects redundant enabling of cop of same department - registers offense and corrects unnecessary enable - registers offense and corrects redundant enabling of same department - registers offense and corrects redundant enabling of department of same cop - when middle cop is unnecessarily enabled - registers an offense and corrects - registers an offense and corrects when there is extra white space - when all cops are unnecessarily enabled - on the same line - registers an offense and corrects - on separate lines - registers an offense and corrects when there is extra white space - all switch - registers offense and corrects unnecessary enable all - when at least one cop was disabled - does not register offense - -RuboCop::Cop::Style::StringLiteralsInInterpolation - when configured with a bad value - fails - configured with single quotes preferred - accepts double quotes on a static string - registers an offense for double quotes within embedded expression - registers an offense for double quotes within embedded expression in a heredoc string - accepts double quotes on static strings within a method - can handle character literals - can handle a built-in constant parsed as string - accepts double quotes on a broken static string - configured with double quotes preferred - registers an offense for single quotes within embedded expression in a heredoc string - registers an offense for single quotes within embedded expression - -RuboCop::Cop::Style::PerlBackrefs - autocorrects $1 to ::Regexp.last_match(1) in namespace - autocorrects $+ to Regexp.last_match(-1) - autocorrects $PREMATCH to Regexp.last_match.pre_match - autocorrects $& to Regexp.last_match(0) - autocorrects puts $1 to puts Regexp.last_match(1) - autocorrects "#$1" to "#{Regexp.last_match(1)}" - autocorrects $MATCH to Regexp.last_match(0) - autocorrects $LAST_PAREN_MATCH to Regexp.last_match(-1) - autocorrects $' to Regexp.last_match.post_match - autocorrects $POSTMATCH to Regexp.last_match.post_match - autocorrects $9 to Regexp.last_match(9) - autocorrects `#$1` to `#{Regexp.last_match(1)}` - autocorrects $` to Regexp.last_match.pre_match - autocorrects /#$1/ to /#{Regexp.last_match(1)}/ - -RuboCop::Cop::Style::ParallelAssignment - registers an offense when assigning to namespaced constants - corrects when the right variable is an array - allows more left variables than right variables - corrects parallel assignment in if statements - registers an offense when assignments must be reordered to preserve meaning - corrects when the expression uses a modifier rescue statement as the only thing inside of a method - corrects when the expression uses a modifier rescue statement - registers an offense when the right side has mulitiple arrays - corrects when the expression uses a modifier while statement - corrects parallel assignment in unless statements - allows expanding an assigned var - corrects when assigning from multiple methods with blocks - corrects when the right variable is a symbol array - corrects when the expression uses a modifier unless statement - corrects when using constants - allows more right variables than left variables - corrects when the expression uses a modifier if statement - corrects parallel assignment in rescue statements within begin ... rescue - corrects parallel assignment inside rescue statements within method definitions - registers an offense with indices and attributes when assignments must be reordered to preserve meaning - corrects when the right variable is a word array - registers an offense when the right side has mixed expressions - registers an offense when right hand side has namespaced constants - corrects when using nested indentation - registers an offense when assigning to same variables in same order - corrects when the expression uses a modifier rescue statement inside of a method - registers an offense when right hand side has maps with blocks - corrects when assigning to method returns - corrects when the number of left hand variables matches the number of right hand variables - corrects when the expression uses a modifier until statement - registers an offense with indices of different variables - registers an offense when the right side has multiple hashes - registers an offense when left hand side ends with an implicit variable - registers an offense when the right side has methods with/without blocks - registers an offense with attributes when assignments must be reordered to preserve meaning - registers an offense with indices - corrects parallel assignment in until statements - corrects when using parallel assignment in singleton method - corrects when the expression uses a modifier if statement inside a method - registers an offense when the right side has constants - corrects parallel assignment in while statements - corrects when using single indentation - corrects when assignments must be reordered to avoid changing meaning - corrects when the expression is missing spaces - behaves like allowed - allows assignment of: a[0], a[1] = a[1], a[0] - behaves like allowed - allows assignment of: a, b, c = *node, 1, 2 - behaves like allowed - allows assignment of: a, b = (a + b), (a - b) - behaves like allowed - allows assignment of: a, *b = [1, 2, 3] - behaves like allowed - allows assignment of: a = 1 - behaves like allowed - allows assignment of: obj.attr1, obj.attr2 = obj.attr2, obj.attr1 - behaves like allowed - allows assignment of: array = [1, 2, 3]; a, = array; - behaves like allowed - allows assignment of: CONSTANT, = 1, 2 - behaves like allowed - allows assignment of: a, b = *foo - behaves like allowed - allows assignment of: a, = 1 - behaves like allowed - allows assignment of: a, b = foo.map { |e| e.id } - behaves like allowed - allows assignment of: a, b = foo() - behaves like allowed - allows assignment of: a = a - behaves like allowed - allows assignment of: begin_token, end_token = CONSTANT - behaves like allowed - allows assignment of: a = *'foo' - behaves like allowed - allows assignment of: self.a, self.b = b, a - behaves like allowed - allows assignment of: *a, b = [1, 2, 3] - behaves like allowed - allows assignment of: ary[0], ary[1], ary[2] = ary[1], ary[2], ary[0] - behaves like allowed - allows assignment of: obj.attr1, ary[0] = ary[0], obj.attr1 - behaves like allowed - allows assignment of: self.a, self.b = self.b, self.a - behaves like allowed - allows assignment of: a, b, c = b, c, a - behaves like allowed - allows assignment of: a, b = Float::INFINITY - behaves like allowed - allows assignment of: a, = 1, 2, 3 - behaves like allowed - allows assignment of: a, b = b, a - behaves like allowed - allows assignment of: a = 1; b = 2; - behaves like allowed - allows assignment of: a, = *foo - behaves like allowed - allows assignment of: foo = [1, 2, 3]; a, b, c = foo; - behaves like allowed - allows assignment of: a, b, c = 1, 2, *node - behaves like allowed - allows assignment of: a, = a - behaves like allowed - allows assignment of: a, = *'foo' - using custom indentation width - works with rescue - works with guard clauses - works with standard correction - works with nesting - -RuboCop::Cop::Style::InverseMethods - allows an inverse method when double negation is used - registers an offense for !foo.exclude? - registers an offense for comparing snake case constants on the right - registers an offense for not (foo != bar) - registers an offense for !(foo < bar) - registers an offense for calling !.none? with a symbol proc - registers an offense for !foo.include? - allows comparing camel case constants on the left - registers an offense for !(foo =~ bar) - registers an offense for comparing snake case constants on the left - allows a method call without a not - registers an offense for not (foo == bar) - registers an offense for calling !.any? inside parens - registers an offense for !foo.blank? - registers an offense for !foo.any? - allows an inverse method in a block with next - registers an offense for !foo.none? - registers an offense for !foo.present? - registers an offense for not (foo < bar) - registers an offense for !(foo !~ bar) - registers an offense for !foo.odd? - registers an offense for !(foo > bar) - registers an offense for calling !.none? with a block - registers an offense for not (foo > bar) - registers an offense for !(foo == bar) - allows an inverse method with a block when double negation is used - registers an offense for not (foo !~ bar) - registers an offense for !(foo != bar) - registers an offense for not (foo =~ bar) - allows comparing camel case constants on the right - registers an offense for !foo.even? - behaves like all variable types - registers an offense for calling !@@foo.none? - registers an offense for calling not @@foo.none? - behaves like all variable types - registers an offense for calling not FOO.none? - registers an offense for calling !FOO.none? - Ruby 2.7 - registers an offense for calling !.none? with a numblock - inverse blocks - corrects an inverted method call when using `BasicObject#!` with spaces before the method call - registers a single offense for nested inverse method calls - corrects an inverted method call when using `BasicObject#!` with spaces before the method call - registers an offense for an inverted equality block - registers an offense for a multiline method call where the last method is inverted - registers a single offense for nested inverse method calls - registers an offense for a multiline method call where the last method is inverted - registers an offense for an inverted equality block - registers an offense for a multiline method call where the last method is inverted - registers a single offense for nested inverse method calls - corrects an inverted method call when using `BasicObject#!` - corrects an inverted method call when using `BasicObject#!` with spaces before the method call - corrects a complex inverted method call - registers an offense for a multiline inverted equality block - corrects an inverted method call when using `BasicObject#!` with spaces before the method call - corrects an inverted method call when using `BasicObject#!` - corrects an inverted method call - corrects an inverted method call when using `BasicObject#!` - registers an offense for a multiline method call where the last method is inverted - corrects a complex inverted method call - corrects an inverted do end method call - corrects a complex inverted method call - corrects an inverted do end method call - corrects an inverted method call when using `BasicObject#!` - registers an offense for a multiline inverted equality block - corrects an inverted do end method call - registers an offense for foo.reject { |e| !e } - corrects an inverted method call - registers an offense for an inverted equality block - registers an offense for foo.select! { |e| !e } - registers an offense for foo.reject! { |e| !e } - corrects a complex inverted method call - registers an offense for a multiline inverted equality block - registers a single offense for nested inverse method calls - corrects an inverted do end method call - corrects an inverted method call - registers an offense for a multiline inverted equality block - registers an offense for foo.select { |e| !e } - registers an offense for an inverted equality block - corrects an inverted method call - behaves like all variable types - registers an offense for calling !@foo.none? - registers an offense for calling not @foo.none? - behaves like all variable types - registers an offense for calling !foo.bar.none? - registers an offense for calling not foo.bar.none? - behaves like all variable types - registers an offense for calling !foo.none? - registers an offense for calling not foo.none? - behaves like all variable types - registers an offense for calling not foo["bar"].none? - registers an offense for calling !foo["bar"].none? - behaves like all variable types - registers an offense for calling !$foo.none? - registers an offense for calling not $foo.none? - behaves like all variable types - registers an offense for calling !FOO::BAR.none? - registers an offense for calling not FOO::BAR.none? - -RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords - accepts empty begin - with complex begin-end - registers many offenses - registers an offense for above rescue keyword with a blank - with complex method definition - registers many offenses - registers an offense for rescue section starting with a blank - accepts `rescue` and `end` are on the same line - registers an offense for rescue section ending with a blank - accepts `begin` and `rescue` are on the same line - accepts `def` and `rescue` are on the same line - registers an offense for rescue section ending for method definition a blank - accepts no empty line - accepts last `rescue` and `end` are on the same line - accepts empty lines around begin body - accepts empty method definition - -RuboCop::Cop::Style::AutoResourceCleanup - does not register an offense for File.open with immediate close - does not register an offense for File.open with block-pass - registers an offense for File.open without block - does not register an offense for File.open with block - -RuboCop::Cop::VariableForce - #process_node - when processing a regex with regopt - does not raise an error - when processing a regexp with a line break at the start of capture parenthesis - does not raise an error - when processing lvar node - when the variable is not yet declared - does not raise error - when processing an empty regex - does not raise an error +RuboCop::Cop::Style::ExponentialNotation + EnforcedStyle is engineering + registers no offense for a regular float + registers an offense for a mantissa greater than -0.1 + registers an offense for mantissa smaller than 0.1 + registers an offense for mantissa smaller than -1000 + registers no offense for a negative mantissa + registers no offense for a large mantissa + registers an offense for exponent equal to -2 + registers no offense for a negative exponent + registers no offense for a float smaller than 1 + registers no offense for a mantissa equal to 1 + registers an offense for exponent equal to 4 + EnforcedStyle is integral + registers no offense for negative mantissa + registers no offense for negative exponent + registers no offense for a float smaller than 1 + registers an offense for decimal mantissa + registers no offense for a regular float + registers an offense for mantissa divisible by 10 + registers no offense for an integral mantissa + EnforcedStyle is scientific + registers no offense for a float smaller than 1 + registers no offense for a negative exponent + registers no offense for a negative mantissa + registers an offense for mantissa greater than 10 + registers an offense for mantissa smaller than 1 + registers no offense for a mantissa equal to 1 + registers no offense for a mantissa between 1 and 10 + registers no offense for a regular float + registers an offense for mantissa equal to 10 RuboCop::Cop::Lint::UselessTimes - registers an offense and corrects with 1.times with method chain + does not register an offense for an integer > 1 registers an offense and corrects with 1.times with block arg + registers an offense and corrects with 0.times with block arg registers an offense and corrects with negative times - registers an offense and corrects with 0.times + registers an offense and corrects when there is a blank line in the method definition registers an offense and corrects when 1.times with empty block argument registers an offense and corrects with negative times with block arg - registers an offense and corrects with 0.times with block arg - does not register an offense for an integer > 1 - registers an offense and corrects when there is a blank line in the method definition + registers an offense and corrects with 0.times + registers an offense and corrects with 1.times with method chain registers an offense and corrects with 1.times short-form method does not adjust surrounding space - registers an offense and corrects with 1.times + registers an offense and corrects with negative times registers an offense and corrects with 0.times does not register an offense for an integer > 1 - registers an offense and corrects with negative times + registers an offense and corrects with 1.times within indentation - corrects properly when removing single line corrects properly when replacing + corrects properly when removing single line corrects properly when removing multiline inline `Integer#times` calls does not try to correct `0.times` does not try to correct `1.times` multiline block - correctly handles a multiline block with 1.times - does not try to correct a block if the block arg is changed corrects a block that changes another lvar does not try to correct a block if the block arg is changed in parallel assignment + correctly handles a multiline block with 1.times + does not try to correct a block if the block arg is changed -RuboCop::Cop::Lint::RedundantSafeNavigation - does not register an offense when using `&.` outside of conditions - registers an offense and corrects when `&.` is used inside `#{loop_type}` condition - does not register an offense when using `&.respond_to?` with `nil` specific method as argument in condition - registers an offense and corrects when `&.` is used inside complex condition - does not register an offense when using `&.` with non-allowed method in condition - registers an offense and corrects when `&.` is used inside `if` condition - registers an offense and corrects when `&.` is used inside `unless` condition - registers an offense and corrects when `&.` is used inside `#{loop_type}` condition +RuboCop::Cop::Lint::AmbiguousRange + for an erange + does not register an offense for `self` + does not register an offense for a constant + can handle an endless range + does not register an offense for a variable + registers an offense and corrects when the entire range is parenthesized but contains complex boundaries + does not register an offense if the range is composed of literals + registers an offense and corrects when one side is parenthesized but the other is not + registers an offense and corrects when not parenthesized + registers an offense and corrects when there are clauses on both sides + does not register an offense if the range is parenthesized + can handle a beginningless range + method calls + with RequireParenthesesForMethodChains: true + registers an offense for a chained method call without parens + does not register an offense for a chained method call with parens + behaves like common behavior + does not register an offense for a unary - + does not register an offense for a non-chained method call + does not register an offense for a unary + + requires parens when calling a method on a basic literal + with RequireParenthesesForMethodChains: false + does not register an offense for a chained method call with parens + does not register an offense for a chained method call without parens + behaves like common behavior + does not register an offense for a unary - + does not register an offense for a unary + + does not register an offense for a non-chained method call + requires parens when calling a method on a basic literal + for an irange + does not register an offense for a constant + can handle a beginningless range + does not register an offense if the range is parenthesized + does not register an offense for a variable + registers an offense and corrects when one side is parenthesized but the other is not + registers an offense and corrects when not parenthesized + registers an offense and corrects when the entire range is parenthesized but contains complex boundaries + can handle an endless range + registers an offense and corrects when there are clauses on both sides + does not register an offense for `self` + does not register an offense if the range is composed of literals + method calls + with RequireParenthesesForMethodChains: true + registers an offense for a chained method call without parens + does not register an offense for a chained method call with parens + behaves like common behavior + does not register an offense for a non-chained method call + does not register an offense for a unary - + does not register an offense for a unary + + requires parens when calling a method on a basic literal + with RequireParenthesesForMethodChains: false + does not register an offense for a chained method call without parens + does not register an offense for a chained method call with parens + behaves like common behavior + does not register an offense for a unary + + does not register an offense for a non-chained method call + requires parens when calling a method on a basic literal + does not register an offense for a unary - -RuboCop::Cop::Style::NumericLiterals - autocorrects numbers with spaces between leading minus and numbers - registers an offense for a long undelimited integer - handles numeric literal with exponent - autocorrects numeric literal with exponent (large E) and dot - accepts integers with less than three places at the end - autocorrects numeric literal with exponent and dot - autocorrects negative numbers - accepts short numbers without underscore - accepts long numbers with underscore - does not count a leading minus sign as a digit - registers an offense for an integer with misplaced underscore - registers an offense for a float with a long undelimited integer part - ignores non-decimal literals - accepts a short integer without underscore - autocorrects negative floating-point numbers - for --auto-gen-config - when the number is only digits - detects right value of MinDigits based on the longest number - sets the right value if one is disabled inline - with separators - does not disable the cop if the line is disabled - disables the cop - when `3000` is specified for `AllowedNumbers` - does not register an offense - registers an offense - strict - registers an offense for an integer with misplaced underscore - AllowedPatterns - does not register an offense for numbers that exactly match the pattern - registers an offense for numbers that do not exactly match the pattern - corrects by inserting underscores every 3 digits - AllowedPatterns with repetition - does not register an offense for numbers that match the pattern - when `'3000'` is specified for `AllowedNumbers` - does not register an offense - registers an offense +RuboCop::Cop::Layout::SpaceAfterMethodName + registers offense and corrects class def with space before parenthesis + accepts a def with arguments but no parentheses + registers an offense and corrects def with space before the parenthesis + accepts a def without arguments + accepts class method def with arguments but no parentheses + accepts an assignment def with arguments but no parentheses + accepts a defs without arguments + registers offense and corrects assignment def with space before parenthesis -RuboCop::Cop::Style::MapCompactWithConditionalBlock - With single line block - registers an offense and corrects to `select` with ternary expression - registers an offense and corrects to `reject` with ternary expression - does not register offenses if `compact` is not chained to `map` - registers an offense and corrects to `reject` with modifier form of `unless` condition - registers an offense and corrects to `select` with modifier form of `if` condition - With multiline block - registers an offense and corrects to `select` if `next value` in if_branch and `nil` in else_branch - registers an offense and corrects to `select` with ternary expression - registers an offense and corrects to `reject` with guard clause of `unless` - registers an offense and corrects to `select` with `if` condition - registers an offense and corrects to `reject` with `unless` condition - registers an offense and corrects to `reject` with `if` condition - registers an offense and corrects to `reject` with modifier form of `unless` condition - registers an offense and corrects to `reject` with ternary expression - does not register offenses if there are multiple guard clauses - registers an offense and corrects to `select` with guard clause of `if` and next explicitly nil - registers an offense and corrects to `reject` if `next value` in else_branch and `nil` in if_branch - registers an offense and corrects to `select` with guard clause of `if` and `next` has a value - does not register offenses if `compact` is not chained to `map` - registers an offense and corrects to `reject` with guard clause of `unless` and `next` has a value - does not register offenses if condition has elsif branch - does not register offenses if return value is not same as block argument - registers an offense and corrects to `select` if condition has not else branch - registers an offense and corrects to `reject` with guard clause of `unless` and `next` has a value and return nil - registers an offense and corrects to `select` with modifier form of `if` condition - registers an offense and corrects to `select` with guard clause of `if` - registers an offense and corrects to `select` with guard clause of `if` and `next` has a value and return nil - registers an offense and corrects to `select` with multi-line `if` condition - registers an offense and corrects to `reject` with guard clause of `unless` and `next` explicitly nil +RuboCop::Cop::Naming::AsciiIdentifiers + when AsciiConstants is true + does not get confused by a byte order mark + registers an offense for a variable name with mixed chars + accepts identifiers with only ascii chars + does not get confused by an empty file + registers an offense for a constant name with non-ascii chars + registers an offense for a variable name with non-ascii chars + when AsciiConstants is false + accepts constants with only ascii chars + registers an offense for a variable name with non-ascii chars + registers an offense for a variable name with mixed chars + does not get confused by an empty file + does not get confused by a byte order mark + accepts identifiers with only ascii chars -RuboCop::Cop::Style::KeywordParametersOrder - registers an offense and corrects when `kwoptarg` is before `kwarg` - registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`sand last argument is `kwrestarg` and argument parentheses omitted - registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`s - registers an offense and corrects when multiple `kwoptarg` are before `kwarg` and argument parentheses omitted - registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`sand last argument is `blockarg` and argument parentheses omitted - does not register an offense when there are no `kwoptarg`s before `kwarg`s - registers an offense and corrects when `kwoptarg` is before `kwarg` and argument parentheses omitted - when using block keyword parameters - registers an offense and corrects when `kwoptarg` is before `kwarg` - does not register an offense when there are no `kwoptarg`s before `kwarg`s +RuboCop::Cop::Style::ColonMethodDefinition + accepts a class method defined using . + using self + registers an offense for a class method defined using :: + using the class name + registers an offense for a class method defined using :: -RuboCop::Cop::Style::WordArray - with a WordRegex configuration which accepts almost anything - uses %W when autocorrecting strings with non-printable chars - uses %w for strings which only appear to have an escape - when EnforcedStyle is array - doesn't fail on strings which are not valid UTF-8 - doesn't fail with `encoding: binary - does not register an offense for arrays of double quoted strings - autocorrects a %w() array which uses string with hyphen - autocorrects multiline %w() array - autocorrects a %w() array which uses single quotes - does not register an offense for arrays of single quoted strings - registers an offense for an empty %w() array - does not register an offense for arrays of strings with spaces - autocorrects a %W() array which uses string interpolation - registers an offense for a %w() array - autocorrects a %W() array which uses escapes - autocorrects a %W() array which uses string with hyphen - does not register an offense for arrays of strings with hyphens - with a custom WordRegex configuration - registers an offense for arrays of email addresses - with a treacherous WordRegex configuration - doesn't break when words contain whitespace - doesn't break when words contain delimiters - when PreferredDelimiters is specified - autocorrects an array with delimiters - when EnforcedStyle is percent - does not register an offense for a %w() array containing non word characters - does not register offense for array with allowed number of strings - detects when the cop must be disabled to avoid offenses - does not register an offense for array of non-words - autocorrects an array with one element - does not register an offense on non-word strings - detects right value of MinSize to use for --auto-gen-config - does not register an offense for an array with comments in it - autocorrects an array of words - does not register an offense for array containing non-string - registers an offense for an array with comments outside of it - registers an offense for arrays of strings containing hyphens - autocorrects an array of words using partial newlines - autocorrects an array of words in multiple lines - uses %W when autocorrecting strings with embedded newlines and tabs - registers an offense in a non-ambiguous block context - registers an offense for strings with newline and tab escapes - registers an offense for arrays of single quoted strings - registers an offense for a %w() array containing spaces - registers an offense for arrays of double quoted strings - doesn't fail in wacky ways when multiple cop instances are used - autocorrects an array of words and character constants - does not register an offense for array with empty strings - does not register an offense for array starting with %w - corrects properly when there is an extra trailing comma - keeps the line breaks in place after autocorrect - registers an offense for arrays with character constants - when the default external encoding is US-ASCII - registers an offense for arrays of unicode word characters - when the default external encoding is UTF-8 - registers an offense for arrays of unicode word characters - when the WordRegex configuration is not a Regexp - still parses the code without raising an error - with non-default MinSize - does not autocorrect arrays of one symbol if MinSize > 1 +RuboCop::Cop::Style::DefWithParentheses + reports an offense for class def with empty parens + accepts def without arguments + accepts empty parentheses in one liners + reports an offense for def with empty parens + accepts def with arg and parens + Ruby >= 3.0 + reports an offense for endless method definition with empty parens -RuboCop::Cop::Team - #forces - returns force instances - when a cop joined a force - returns the force - when multiple cops joined a same force - returns only one force instance - when no cops joined force - returns nothing - #external_dependency_checksum - does not error with no cops - when a cop joins - returns string - when cop with different checksum joins - has a different checksum for the whole team - when multiple cops join - returns string - .new - calls mobilize when passed classes - accepts cops directly classes - #cops - returns cop instances - when some classes are disabled with config - does not return instances of the classes - when only some cop classes are passed to .new - returns only instances of the classes - #debug? - when { debug: true } is passed to .new - is expected to be truthy - when the option argument of .new is omitted - is expected to be falsey - #autocorrect? - when the option argument of .new is omitted - is expected to be falsey - when { autocorrect: true } is passed to .new - is expected to be truthy - when incompatible cops are correcting together - autocorrects without SyntaxError - #inspect_file - returns offenses - when a correction raises an error - records Team#errors - when done twice - allows cops to get ready - when Parser reports non-fatal warning for the file - returns offenses from cops - returns Parser warning offenses - when a cop has no interest in the file - returns all offenses except the ones of the cop - when autocorrection is enabled and file encoding is mismatch - no error occurs - when Cop#on_* raises an error - records Team#errors - when autocorrection is enabled - does autocorrection - still returns offenses +RuboCop::Cop::Lint::Void + registers two offenses for void literals in a `for` + registers an offense for void var @@var if not on last line + accepts void unary op ! by itself without a begin block + registers an offense for void op < if not on last line + registers an offense for void lit 2.0 if not on last line + registers an offense for void op != if not on last line + accepts backtick commands + accepts void op <=> if on last line + accepts void op + by itself without a begin block + accepts void op / if on last line + registers two offenses for void literals in a setter method + accepts void op >= by itself without a begin block + accepts void op % by itself without a begin block + registers an offense for void sign op - if not on last line + registers an offense for void var var if not on last line + accepts void op + if on last line + accepts void op < if on last line + accepts void op % if on last line + registers an offense for void op - if not on last line + registers an offense for void op <= if not on last line + registers an offense for void lit 1 if not on last line + registers an offense for void var VAR if not on last line + registers an offense for void lit :test if not on last line + registers an offense for void literal in a method definition + registers an offense for void var @var if not on last line + registers an offense for void op % if not on last line + accepts void op === by itself without a begin block + accepts void unary op + by itself without a begin block + registers an offense for void `defined?` if not on last line + accepts void op <=> by itself without a begin block + registers an offense for void lit [1] if not on last line + accepts void op > by itself without a begin block + accepts void unary op - if on last line + accepts percent-x commands + accepts void op - if on last line + accepts void op >= if on last line + accepts void op - by itself without a begin block + registers two offenses for void literals in a `#each` method + accepts void op / by itself without a begin block + handles `#each` block with single expression + registers an offense for void op > if not on last line + accepts void unary op ~ if on last line + registers an offense for void lit {} if not on last line + registers an offense for void unary op ~ if not on last line + registers an offense for void op === if not on last line + accepts void unary op - by itself without a begin block + accepts void op != by itself without a begin block + accepts void op <= by itself without a begin block + registers an offense for void op >= if not on last line + accepts void op < by itself without a begin block + registers an offense for void sign op + if not on last line + accepts void unary op ! if on last line + registers an offense for void op <=> if not on last line + registers an offense for void op + if not on last line + accepts method with erange block + accepts void op * by itself without a begin block + accepts method with irange block + registers an offense for void op / if not on last line + accepts empty block + registers an offense for void unary op ! if not on last line + registers an offense for void var $var if not on last line + registers two offenses for void literals in an initialize method + registers an offense for void lit /test/ if not on last line + accepts void op == if on last line + registers an offense for void `self` if not on last line + accepts void op != if on last line + accepts void op == by itself without a begin block + handles explicit begin blocks + accepts void unary op + if on last line + registers an offense for void op * if not on last line + registers an offense for void op == if not on last line + accepts void op > if on last line + accepts void op === if on last line + accepts void op * if on last line + registers two offenses for void literals in `#tap` method + accepts void unary op ~ by itself without a begin block + accepts void op <= if on last line + accepts short call syntax + when not checking for methods with no side effects + does not register an offense for void nonmutating methods + when checking for methods with no side effects + registers an offense if not on last line + registers an offense for chained methods + Ruby 2.7 + registers two offenses for void literals in `#tap` method -RuboCop::Cop::Style::WhenThen - registers an offense for when b, c; - registers an offense for when b; - accepts ; separating statements in the body of when - when inspecting a case statement with an empty branch - does not register an offense +RuboCop::CommentConfig + comment_only_line? + when line contains only code + returns false + returns false + returns false + returns false + when line contains code and comment + returns false + when line contains only comment + returns true + returns true + when line is empty + returns true + #cop_disabled_line_ranges + collects line ranges by disabled cops + #extra_enabled_comments + has keys as instances of Parser::Source::Comment for extra enabled comments + has values as arrays of extra enabled cops + #cop_enabled_at_line? + handles indented single line + supports disabling cops with numbers in their name + supports disabling multiple lines with a pair of directive + can handle double disable of one cop + supports disabling single line with a directive at end of line + supports disabling all cops except Lint/RedundantCopDisableDirective with keyword all + supports disabling all lines after a directive + supports enabling/disabling multiple cops along with a comment + does not confuse a cop name including "all" with all cops + supports enabling/disabling multiple cops in a single directive + does not confuse a comment directive embedded in a string literal with a real comment + supports enabling/disabling cops without a prefix + supports disabling cops with multiple levels in department name + supports disabling cops with multiple uppercase letters + supports disabling cops on a comment line with an EOL comment + just ignores unpaired enabling directives -RuboCop::Cop::Lint::ConstantOverwrittenInRescue - does not register an offense when not overriding an exception with an exception result - registers an offense when overriding an exception with an exception result - does not register an offense when using `=>` but correctly assigning to variables +RuboCop::Cop::Layout::FirstParameterIndentation + consistent style + no paren method defs + ignores + ignores with hash args + valid indentation on static multi-line defs + accepts correctly indented first element + accepts correctly indented first element hash + invalid indentation on multi-line defs + hash arguments static method def + registers an offense and corrects incorrectly indented first element + normal arguments + registers an offense and corrects incorrectly indented first element + hash arguments + registers an offense and corrects incorrectly indented first element + valid indentation on multi-line defs + accepts correctly indented first element + accepts correctly indented first element hash + single line method defs + ignores with hash args + ignores + align_parentheses style + valid indentation on multi-line defs + accepts correctly indented first element + accepts correctly indented first element hash + invalid indentation on multi-line defs + normal arguments + registers an offense and corrects incorrectly indented first element + hash arguments + registers an offense and corrects incorrectly indented first element + hash arguments static def + registers an offense and corrects incorrectly indented first element + no paren method defs + ignores with hash args + ignores + single line method defs + ignores with hash args + ignores -RuboCop::Cop::Lint::IneffectiveAccessModifier - when `private_class_method` is used - when `private_class_method` contains all private method names - doesn't register an offense - when `private_class_method` does not contain the method - registers an offense - when `private` is applied to a class method - registers an offense - when `protected` is applied to a class method - registers an offense - when there is `begin` before a method definition +RuboCop::Cop::Lint::HashCompareByIdentity + does not register an offense for hash methods without `object_id` as key + registers an offense when using hash methods with `object_id` on receiver as a key + registers an offense when using hash method with `object_id` as a key + +RuboCop::Cop::Style::Next + does not blow up on empty body until block + handles `then` when autocorrecting + does not blow up on empty body while block + does not crash with empty brackets + keeps comments when autocorrecting + handles nested autocorrections + allows empty blocks + does not crash with an empty body branch + allows loops with conditions at the end with ternary op + allows super nodes + doesn't reindent heredoc bodies when autocorrecting + does not blow up on empty body for block + MinBodyLength: 3 + accepts if whose body has 1 line + behaves like iterators + registers an offense for if inside of map + allows loops with if with else at the end + allows loops with conditional break + allows loops with if being the entire body with else + registers an offense for if inside of each_with_object + registers an offense for if inside of each + registers an offense for if inside of reject + registers an offense for if inside of collect + registers an offense for if inside of select! + registers an offense when line break before condition + registers an offense for a condition at the end of an iterator when there is more in the iterator than the condition + registers an offense for if inside of reject! + registers an offense for if inside of select + registers an offense for if inside of times + autocorrects a misaligned end + registers an offense for if inside of loop + registers an offense for if inside of nested iterators + registers an offense for if inside of nested iterators + registers an offense for if inside of downto + reports an offense for if whose body has 3 lines + allows loops with if with else, nested in another condition + registers an offense for if inside of for + allows loops with conditional return + Ruby 2.7 + registers an offense for if inside of downto numblock + EnforcedStyle: always + registers an offense for modifier if + EnforcedStyle: skip_modifier_ifs + allows modifier if + Invalid MinBodyLength + fails with an error + behaves like iterators + registers an offense for unless inside of reject + registers an offense for a condition at the end of an iterator when there is more in the iterator than the condition + registers an offense for unless inside of reject! + registers an offense for unless inside of select! + registers an offense for unless inside of collect + allows loops with conditional return + registers an offense when line break before condition + registers an offense for unless inside of each + reports an offense for unless whose body has 3 lines + registers an offense for unless inside of nested iterators + registers an offense for unless inside of select + registers an offense for unless inside of times + registers an offense for unless inside of for + allows loops with unless being the entire body with else + allows loops with unless with else, nested in another condition + autocorrects a misaligned end + registers an offense for unless inside of loop + registers an offense for unless inside of downto + allows loops with conditional break + registers an offense for unless inside of each_with_object + registers an offense for unless inside of map + registers an offense for unless inside of nested iterators + allows loops with unless with else at the end + Ruby 2.7 + registers an offense for unless inside of downto numblock + EnforcedStyle: always + registers an offense for modifier unless + EnforcedStyle: skip_modifier_ifs + allows modifier unless + +RuboCop::Cop::Lint::EmptyInPattern + when a `in` body is present + accepts `case` with `in` ... `then` statements + accepts `case` with `in` ... `then` statements and else clause + accepts `case` with `in` bodies + accepts `case` with `in` bodies and `else` clause + when `AllowComments: false` + registers an offense for empty `in` body with a comment + when a `in` body is missing + registers an offense for missing `in` body followed by `else` + registers an offense for missing `in` body with a comment followed by `else` + registers an offense for missing `in` body with a comment + registers an offense for missing `in` ... `then` body + registers an offense for missing `in` ... then `body` followed by `else` + registers an offense for a missing `in` body + when `AllowComments: true` + registers an offense for empty `in` when comment is in another branch + accepts an empty `in` body with a comment + +RuboCop::Cop::Style::IpAddresses + does not register an offense on an empty string + IPv6 + registers an offense for a shortened address + does not register an offense for an invalid address + registers an offense for the loopback address + registers an offense for an address with 0s collapsed + registers an offense for a valid address + registers an offense for a very short address + the unspecified address :: (shortform of 0:0:0:0:0:0:0:0) + does not register an offense + when it is removed from the allowed addresses + registers an offense + IPv4 + registers an offense for a valid address + does not register an offense for an invalid address + does not register an offense for an address inside larger text + with allowed addresses + does not register an offense for a allowed addresses + does not register an offense if the case differs + +RuboCop::Cop::Layout::FirstHashElementLineBreak + ignores elements listed on a single line + ignores implicit hashes in method calls with parens + registers an offense and corrects elements listed on the first line + registers an offense and corrects single element multi-line hash + ignores implicit hashes in method calls without parens + registers an offense and corrects hash nested in a method call + ignores implicit hashes in method calls that are improperly formatted + +RuboCop::Cop::Lint::SymbolConversion + does not register an offense for a symbol that requires quotes + does not register an offense for a dstr + does not register an offense for a normal symbol + behaves like offense + registers an offense for "foo_bar".intern + in a hash + keys + does not register an offense for a normal symbol + does not register an offense for operators + registers and corrects an offense for a quoted symbol that ends with `?` + does not register an offense for a require quoted symbol + registers and corrects an offense for a quoted symbol that ends with `!` + does not register an offense for a require quoted symbol that contains `:` + does not register an offense for a require quoted symbol that ends with `=` + registers an offense for a quoted symbol + values + registers an offense for a quoted symbol key + does not register an offense for a normal symbol + registers an offense for a quoted symbol value + in an alias does not register an offense - when no access modifier is used - doesn't register an offense - when there is an intervening instance method - still registers an offense - when a `class << self` block is used - doesn't register an offense + inside a percent literal array + does not register an offense + behaves like offense + registers an offense for "foo-bar".to_sym + implicit `to_sym` call + does not register an offense + behaves like offense + registers an offense for "foo_bar".to_sym + behaves like offense + registers an offense for :foo.to_sym + behaves like offense + registers an offense for :"foo" + behaves like offense + registers an offense for :"foo_bar" + behaves like offense + registers an offense for "foo-bar".intern + behaves like offense + registers an offense for "foo".intern + behaves like offense + registers an offense for "foo".to_sym + single quoted symbol + does not register an offense + EnforcedStyle: consistent + hash where no keys need to be quoted + does not register an offense + with a key with = + requires symbols to be quoted + with a mix of string and symbol keys + does not register an offense + hash where keys are quoted but do not need to be + registers an offense + hash where there are keys needing quoting + registers an offense for unquoted keys + with different quote styles + does not register an offense + behaves like offense + registers an offense for :foo.intern -RuboCop::Cop::InternalAffairs::EmptyLineBetweenExpectOffenseAndCorrection - registers and corrects an offense when using no empty line between `expect_offense` and `expect_correction`with variable argument - registers and corrects an offense when using no empty line between `expect_offense` and `expect_no_corrections` - does not register an offense when using empty line between `expect_offense` and `expect_correction` with heredoc argument - does not register an offense when using empty line between `expect_offense` and `expect_no_corrections` - registers and corrects an offense when using no empty line between `expect_offense` and `expect_correction` with heredoc argument - does not register an offense when using empty line between `expect_offense` and `expect_correction`with variable argument - does not register an offense when using only `expect_offense` +RuboCop::Cop::Style::MultilineMethodSignature + when arguments span multiple lines + when defining an class method + registers an offense and corrects when `end` is on the following line + registers an offense and corrects when `end` is on the same line with only closing parentheses + registers an offense and corrects when `end` is on the same line + when correction would not exceed maximum line length + registers an offense and corrects + when correction would exceed maximum line length + does not register an offense + when defining an instance method + registers an offense and corrects when `end` is on the same line with only closing parentheses + registers an offense and corrects when `end` is on the following line + registers an offense and corrects when `end` is on the same line with last argument + when arguments span a single line + when defining an class method + when arguments span a single line + registers an offense and corrects when closing paren is on the following line + when method signature is on a single line + does not register an offense for unparameterized method + does not register an offense for parameterized method + when defining an instance method + registers an offense and corrects when closing paren is on the following line + registers an offense and corrects when line break after opening parenthesis + when method signature is on a single line + does not register an offense for unparameterized method + does not register an offense for parameterized method -RuboCop::Cop::Metrics::AbcSize - when Max is 2 - accepts two assignments - when Max is 1.3 - reports size and max as <1, 1, 4> 4.24/1.3 - when Max is 2.3 - accepts a total score of 2.24 - when Max is 0 - registers an offense for an assignment of an element - registers an offense for an assignment of a local variable - registers an offense for a `define_method` - treats safe navigation method calls like regular method calls + a condition - accepts an empty method - registers an offense for complex content including A, B, and C scores - accepts an empty `define_method` - registers an offense for an if modifier - when CountRepeatedAttributes is `false` - does not count repeated attributes - when method is in list of allowed methods - when AllowedMethods is enabled - does not register an offense when using `define_method` - does not register an offense when defining a class method - does not register an offense when defining an instance method - when AllowedPatterns is enabled - does not register an offense when defining a class method - does not register an offense when using `define_method` - does not register an offense when defining an instance method - when CountRepeatedAttributes is `true` - counts repeated attributes - Ruby 2.7 - registers an offense for a `define_method` with numblock - when Max is 10.3 - reports size and max as <10, 10, 40> 42.43/10.3 - when Max is 100.321 - reports size and max as <100, 100, 400> 424.3/100.3 - when Max is 1000.3 - reports size and max as <1000, 1000, 4000> 4243/1000 +RuboCop::Cop::Style::CollectionMethods + registers an offense for detect with block + registers an offense for collect with an argument and proc param + registers an offense for collect with proc param + accepts find_all without a block + registers an offense for detect with an argument and proc param + registers an offense for member? with block + registers an offense for find_all with an argument and proc param + accepts collect without a block + registers an offense for find_all with proc param + registers an offense for member? with proc param + registers an offense for detect with proc param + accepts detect without a block + registers an offense for find_all with block + registers an offense for member? with an argument and proc param + registers an offense for inject with an argument and proc param + accepts member? without a block + registers an offense for inject with block + registers an offense for collect with block + accepts inject without a block + registers an offense for inject with proc param + Ruby 2.7 + registers an offense for detect with numblock + for methods that accept a symbol as implicit block + registers an offense with an argument and final symbol param + registers an offense with a final symbol param + for methods that do not accept a symbol as implicit block + does not register an offense for a final symbol param with extra args + does not register an offense for a final symbol param + Ruby 2.7 + registers an offense for find_all with numblock + Ruby 2.7 + registers an offense for collect with numblock + Ruby 2.7 + registers an offense for member? with numblock + Ruby 2.7 + registers an offense for inject with numblock -RuboCop::PathUtil - #match_path? - does not match dir/** for file in hidden dir - matches strings to the full path - matches regexps - matches glob expressions - does not match invalid UTF-8 paths - does not match file in a subdirectory - matches dir/** for hidden file - #absolute? - returns a truthy value for a path beginning with slash - returns a falsey value for a path beginning with a directory name - #relative_path - supports custom base paths - builds paths relative to PWD by default as a stop-gap +RuboCop::Cop::Style::RandomWithOffset + registers an offense when using offset - rand(irange) + registers an offense when using offset - ::Random.rand(int) + registers an offense when using Kernel.rand + registers an offense when using ::Kernel.rand + registers an offense when using offset - rand(erange) + registers an offense when using rand(int).next + registers an offense when using offset + rand(int) + registers an offense when using ::Random.rand + does not register an offense when using range with double dots + registers an offense when using rand(erange) + offset + registers an offense when using rand(erange) - offset + registers an offense when using rand(int).pred + does not register an offense when using offset - rand(erange) with a non-integer range value + registers an offense when using ::Random.rand(int).pred + registers an offense when using Random.rand(int).succ + registers an offense when using Random.rand + does not register an offense when using rand(irange) + offset with a non-integer range value + registers an offense when using rand(erange).succ + registers an offense when using offset + Random.rand(int) + registers an offense when using rand(irange) + offset + registers an offense when using rand(irange).succ + registers an offense when using rand(int).succ + does not register an offense when using rand(irange).succ with a non-integer range value + registers an offense when using rand(irange) - offset + registers an offense when using offset - rand(int) + registers an offense when using rand(int) - offset + does not register an offense when using rand(erange).pred with a non-integer range value + registers an offense when using rand(int) + offset + does not register an offense when using range with triple dots -RuboCop::Cop::Lint::ParenthesesAsGroupedExpression - registers an offense and corrects for predicate method call with space before the parenthesis - accepts a method call without arguments - does not register an offesne when heredoc has a space between the same string as the method name and `(` - accepts an operator call with argument in parentheses - accepts a chain of method calls - accepts method with parens as arg to method without - accepts a method call with arguments but no parentheses - does not register an offense for expression followed by an operator - does not register an offense for math expression - does not register an offense for expression followed by chained expression with safe navigation operator - does not register an offense for a call with multiple arguments - does not register an offense when method argument parentheses are omitted and hash argument key is enclosed in parentheses - does not register an offense for expression followed by chained expression - does not register an offense for ternary operator - accepts a space inside opening paren followed by left paren - registers an offense and corrects for method call with space before the parenthesis - does not register an offense for math expression with `to_i` - when using safe navigation operator - registers an offense and corrects for method call with space before the parenthesis +RuboCop::Cop::Naming::RescuedExceptionsVariableName + with default config + with explicit rescue + with method as `Exception` + registers an offense with unexpected variable name + does not register an offense without variable name + does not register an offense with expected variable name + shadowing an external variable + does not register an offense + without `Exception` variable + does not register an offense + with `Exception` variable + does not register an offense when using `_e` + does not register an offense when using _e followed by e + registers offenses when using `foo` and `bar` in multiple rescues + registers an offense when using `exc` and renames its usage + does not register an offense when using `e` + registers an offense when using `exc` + registers an offense when using `_exc` + with lower letters class name + does not register an offense + with splat operator as `Exception` list + does not register an offense with expected variable name + registers an offense with unexpected variable name + does not register an offense without variable name + when the variable is reassigned using multiple assignment + only corrects uses of the exception + when the variable is reassigned + only corrects uses of the exception + only corrects the exception variable + with nested rescues + handles it + with implicit rescue + without `Exception` variable + does not register an offense + with `Exception` variable + does not register an offense when using `e` + does not register an offense when using `_e` + registers an offense when using `_exc` + registers an offense when using `exc` + with variable being referenced + renames the variable references when autocorrecting + with multiple branches + registers and corrects each offense + with the `PreferredName` setup + registers offenses when using `foo` and `bar` in multiple rescues + does not register an offense when using `_exception` + registers an offense when using `_e` + registers an offense when using `e` + does not register an offense when using `exception` -RuboCop::Cop::Lint::DuplicateRescueException - registers an offense when multiple duplicate exceptions exist - registers an offense when duplicate exception exists within rescues with empty `rescue` branch - does not register an offense when there are no duplicate exceptions - registers an offense when duplicate exception exists - registers an offense when duplicate exception exists within rescues with `else` branch - registers an offense when duplicate exception splat exists +RuboCop::Cop::Style::CollectionCompact + registers an offense and corrects when using `reject` on array to reject nils + registers an offense and corrects when using `select/select!` to reject nils + registers an offense and corrects when using `reject` with block pass arg and no parentheses + does not register an offense when using `reject` to not to rejecting nils + registers an offense and corrects when using `reject` and receiver is a variable + registers an offense and corrects when using `reject` with block pass arg on array to reject nils + does not register an offense when using `compact/compact!` + registers an offense and corrects when using `reject` on hash to reject nils + Ruby <= 3.0 + does not register an offense and corrects when using `lazy.reject` on array to reject nils + does not register an offense and corrects when using `to_enum.reject` on array to reject nils + when without receiver + does not register an offense and corrects when using `select/select!` to reject nils + does not register an offense and corrects when using `reject` on array to reject nils + Ruby >= 3.1 + registers an offense and corrects when using `lazy.reject` on array to reject nils + registers an offense and corrects when using `to_enum.reject` on array to reject nils -RuboCop::Cop::Lint::ShadowedException - single rescue - accepts rescuing a multiple exceptions that are not ancestors that have an else - accepts rescue containing multiple same error code exceptions - accepts rescuing a single custom exception - accepts rescuing a custom exception and a standard exception - registers an offense for the same exception multiple times - accepts splat arguments passed to rescue - rescue a exception without causing constant name deprecation warning - registers an offense rescuing Exception with any other error or exception - accepts rescuing a single exception that has an ensure - accepts rescuing a single exception that has an else - accepts rescuing a single exception that is assigned to a variable - registers an offense rescuing exceptions that are ancestors of each other - accepts an empty rescue - accepts rescuing multiple custom exceptions - accepts rescuing a single exception - when there are multiple levels of exceptions in the same rescue - registers an offense for more than two exceptions - registers an offense for two exceptions - multiple rescues - accepts rescuing exceptions in order of level - accepts rescuing exceptions in order of level with multiple exceptions in a group - registers an offense rescuing Exception before an unknown exceptions - registers an offense when a higher level exception is rescued before a lower level exception - accepts many (>= 7) rescue groups - accepts rescuing a known exception after an unknown exceptions - accepts rescuing a known exception between unknown exceptions - accepts rescuing a known exception before an unknown exceptions - registers an offense when a higher level exception is rescued before a lower level exception when there are multiple exceptions rescued in a group - ignores expressions of non-const - registers an offense rescuing out of order exceptions when there is an ensure - registers an offense for two exceptions when there are multiple levels of exceptions in the same rescue - accepts rescuing custom exceptions in multiple rescue groups - accepts rescuing exceptions in order of level with multiple exceptions in a group with custom exceptions - last rescue does not specify exception class - highlights range ending at rescue keyword - splat arguments - registers an offense for splat arguments rescued after rescuing Exception - does not register an offense for splat arguments rescued after rescuing a known exception - accepts splat arguments passed to multiple rescues - exceptions from different ancestry chains - accepts rescuing exceptions in one order - accepts rescuing exceptions in another order - modifier rescue - accepts rescue in its modifier form +RuboCop::Cop::Style::BeginBlock + reports an offense for a BEGIN block -RuboCop::Cop::Style::DocumentationMethod - when declaring methods outside a class - when declaring methods in a module - with documentation comment - when method is public - does not register an offense with `end` on the same line - does not register an offense - when method is module_function - does not register an offense for separate def - does not register an offense for inline def - with both public and private methods - when the public method has no documentation - registers an offense - when the public method has documentation - does not register an offense - when required for non-public methods - registers an offense - without documentation comment - when method is public - registers an offense with `end` on the same line - registers an offense - when method is private - does not register an offense with inline `private` and `end` - does not register an offense with `end` on the same line - does not register an offense with inline `private` - does not register an offense - when required for non-public methods - registers an offense with inline `private` and `end` - registers an offense with inline `private` - registers an offense - registers an offense with `end` on the same line - when method is module_function - registers an offense for separate def - registers an offense for inline def - when declaring methods in a class - with both public and private methods - when the public method has no documentation - registers an offense - when required for non-public methods - registers an offense - when the public method has documentation - does not register an offense - with documentation comment - when method is public - does not register an offense with `end` on the same line - does not register an offense - without documentation comment - when method is public - registers an offense - registers an offense with `end` on the same line - when method is private - does not register an offense with inline `private` and `end` - does not register an offense with inline `private` - does not register an offense with `end` on the same line - does not register an offense - when required for non-public methods - registers an offense with inline `private` and `end` - registers an offense with inline `private` - registers an offense - registers an offense with `end` on the same line - with annotation comment +RuboCop::Cop::Layout::RescueEnsureAlignment + accepts correctly aligned rescue/ensure with def + accepts aligned rescue in do-end block assigned to class + accepts aligned rescue in assigned do-end block starting on newline + accepts correctly aligned rescue/ensure with def with no body + accepts aligned rescue with do-end block that line break with leading dot for method calls + accepts rescue and ensure on the same line + accepts aligned rescue in do-end block with `.()` call + accepts aligned rescue in do-end block on or-assignment + accepts aligned rescue in do-end block + accepts end being misaligned + accepts aligned rescue in do-end block assigned to instance variable + accepts aligned rescue in do-end block on and-assignment + accepts aligned rescue with do-end block that line break with trailing dot for method calls + accepts aligned rescue in do-end block assigned to global variable + accepts aligned rescue do-end block assigned to local variable + accepts aligned rescue in do-end block on operation assignment + accepts correctly aligned rescue + accepts correctly aligned rescue in assigned begin-end block + accepts aligned rescue in do-end block in a method + accepts correctly aligned ensure + accepts the modifier form + accepts aligned rescue in do-end block on multi-assignment + accepts aligned rescue in do-end block assigned to class variable + rescue with do-end block + registers an offense + rescue with def + registers an offense + rescue with class + registers an offense when rescue used with class + allows inline expression before + ensure + registers an offense + rescue + registers an offense + rescue in assigned do-end block starting on newline + registers an offense + rescue in do-end block on and-assignment + registers an offense + rescue in do-end block assigned to instance variable + registers an offense + rescue with begin + registers an offense + as RHS of assignment + `Layout/BeginEndAlignment` cop is not enabled + registers an offense and corrects for incorrect alignment + accepts multi-line, aligned + accepts multi-line, indented + when `EnforcedStyleAlignWith: start_of_line` of `Layout/BeginEndAlignment` cop + accepts multi-line, indented + accepts multi-line, aligned + registers an offense and corrects for incorrect alignment + when `EnforcedStyleAlignWith: begin` of `Layout/BeginEndAlignment` cop + registers an offense and corrects for incorrect alignment + accepts multi-line, indented + accepts multi-line, aligned + ensure with defs + registers an offense + rescue with defs + registers an offense + ensure with def + registers an offense + when using zsuper with block + registers and corrects an offense and corrects when incorrect alignment + does not register an offense when correct alignment + ensure with class + registers an offense + rescue in do-end block assigned to class variable + registers an offense + rescue in do-end block assigned to global variable + registers an offense + rescue in do-end block on or-assignment + registers an offense + excluded file + processes excluded files with issue + rescue in do-end block on operation assignment + registers an offense + ensure with module + registers an offense when ensure used with module + rescue in do-end block on multi-assignment + registers an offense + rescue in do-end block assigned to local variable + registers an offense + rescue in do-end block assigned to class + registers an offense + ensure with begin + registers an offense when ensure used with begin + allows inline access modifier + with public_class_method modifier + rescue with def + correct alignment registers an offense - with directive comment + ensure with defs registers an offense - without documentation comment - when method is protected - does not register an offense - does not register an offense with inline `protected` - when required for non-public methods - registers an offense - registers an offense with inline `protected` - when method is public - registers an offense with `end` on the same line - registers an offense when method is public, but there were private methods before + correct alignment + ensure with def registers an offense - when method is private - does not register an offense with inline `private` and `end` - does not register an offense with inline `private` - does not register an offense with `end` on the same line - does not register an offense - when required for non-public methods - registers an offense with `end` on the same line - registers an offense with inline `private` and `end` - registers an offense - registers an offense with inline `private` - when declaring methods for class instance - without documentation comment - registers an offense with `end` on the same line + correct alignment + rescue with defs registers an offense - with documentation comment - does not register an offense - does not register an offense with `end` on the same line - when method is private - does not register an offense with inline `private` - does not register an offense - does not register an offense with `end` on the same line - does not register an offense with inline `private` and `end` - when required for non-public methods - registers an offense - registers an offense with `end` on the same line - registers an offense with inline `private` - registers an offense with inline `private` and `end` - with both public and private methods - when the public method has documentation - does not register an offense - when the public method has no documentation - registers an offense - when required for non-public methods - registers an offense - with both public and private methods - when required for non-public methods + correct alignment + with private_class_method modifier + ensure with defs + correct alignment registers an offense - when the public method has no documentation + rescue with defs registers an offense - when the public method has documentation - does not register an offense - with documentation comment - does not register an offense with `end` on the same line - does not register an offense + correct alignment + ensure with def + registers an offense + correct alignment + rescue with def + correct alignment + registers an offense + with private modifier + ensure with defs + registers an offense + correct alignment + rescue with defs + correct alignment + registers an offense + rescue with def + correct alignment + registers an offense + ensure with def + registers an offense + correct alignment + rescue with module + registers an offense when rescue used with module -RuboCop::Cop::Style::Strip - registers an offense for str.rstrip.lstrip - registers an offense for str.lstrip.rstrip +RuboCop::Cop::Style::PercentLiteralDelimiters + `default` override + allows all preferred delimiters to be set with one key + allows individual preferred delimiters to override `default` + `%Q` interpolated string + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + registers an offense for other delimiters + does not register an offense for preferred delimiters + does not register an offense for other delimiters when containing preferred delimiter characters + `%` interpolated string + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + registers an offense for a string with no content + does not register an offense for other delimiters when containing preferred delimiter characters + does not register an offense for preferred delimiters + registers an offense for other delimiters + registers an offense when the source contains invalid characters + `%i` symbol array + does not register an offense for preferred delimiters + does not register an offense for non-preferred delimiters enclosing escaped delimiters + registers an offense for other delimiters + `%I` interpolated symbol array + does not register an offense for preferred delimiters + registers an offense for other delimiters + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + `%W` interpolated string array + registers an offense for other delimiters + does not register an offense for other delimiters when containing preferred delimiter characters + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + does not register an offense for preferred delimiters + `%x` interpolated system call + does not register an offense for other delimiters when containing preferred delimiter characters + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + registers an offense for other delimiters + does not register an offense for preferred delimiters + autocorrect + fixes a string array in a scope + preserves indentation when correcting a multiline array + preserves line breaks when fixing a multiline array + preserves irregular indentation when correcting a multiline array + behaves like escape characters + corrects %q with \n in it + corrects %q with \t in it + behaves like escape characters + corrects % with \n in it + corrects % with \t in it + behaves like escape characters + corrects %i with \t in it + corrects %i with \n in it + behaves like escape characters + corrects %W with \n in it + corrects %W with \t in it + behaves like escape characters + corrects %x with \n in it + corrects %x with \t in it + behaves like escape characters + corrects %w with \n in it + corrects %w with \t in it + behaves like escape characters + corrects %r with \n in it + corrects %r with \t in it + behaves like escape characters + corrects %Q with \n in it + corrects %Q with \t in it + behaves like escape characters + corrects %s with \t in it + corrects %s with \n in it + `%r` interpolated regular expression + registers an offense for other delimiters + registers an offense for a regular expression with option + does not register an offense for preferred delimiters + does not register an offense for other delimiters when containing preferred delimiter characters + registers an offense for other delimiters when containing preferred delimiter characters in interpolation + `%w` string array + does not register an offense for preferred delimiters with only a closing delimiter + does not register an offense for preferred delimiters + does not register an offense for other delimiters when containing preferred delimiter characters + does not register an offense for preferred delimiters with not a pairing delimiter + does not register an offense for preferred delimiters with a pairing delimiters + registers an offense for other delimiters + `%q` string + does not register an offense for other delimiters when containing preferred delimiter characters + does not register an offense for preferred delimiters + registers an offense for other delimiters + `%s` symbol + registers an offense for other delimiters + does not register an offense for preferred delimiters + invalid cop config + raises an error when invalid configuration is specified -RuboCop::Cop::Style::Not - parenthesizes when `not` is applied to a ternary op - autocorrects "not" with ! - parenthesizes when `not` is applied to or - does not register an offense for ! - parenthesizes when `not` is applied to and - autocorrects "not" followed by parens with ! - registers an offense for not - uses the reverse operator when `not` is applied to a comparison - parenthesizes when `not` would change the meaning of a binary exp +RuboCop::Cop::Style::FormatString + when enforced style is percent + registers an offense for format with a hash argument + registers an offense and corrects when using springf with second argument that uses an operator + registers an offense for sprintf with 3 arguments + registers an offense for sprintf with a hash argument + accepts String#% + accepts format with 1 argument + registers an offense for sprintf + registers an offense for format with 3 arguments + registers an offense for format + accepts format without arguments + accepts sprintf with 1 argument + accepts sprintf without arguments + when enforced style is sprintf + registers an offense for variable argument and assignment but does not autocorrect + works if the first operand contains embedded expressions + registers an offense for format with 2 arguments + registers an offense for variable argument but does not autocorrect + registers an offense for a string followed by something + does not register an offense for ambiguous cases + does not register an offense for numbers + registers an offense for format + registers an offense for something followed by an array + registers an offense for String#% with a hash argument + when enforced style is format + works if the first operand contains embedded expressions + does not autocorrect String#% with variable argument and assignment + does not register an offense for numbers + registers an offense for variable argument but does not autocorrect + registers an offense for something followed by a hash + registers an offense for something followed by an array + registers an offense for a string followed by something + registers an offense for sprintf with 2 arguments + does not register an offense for ambiguous cases + registers an offense for sprintf -RuboCop::Cop::Style::RedundantFileExtensionInRequire - does not register an offense when requiring filename ending with `.so` - registers an offense and corrects when requiring filename ending with `.rb` - does not register an offense when requiring filename without an extension - does not register an offense when requiring variable as a filename +RuboCop::Cop::Style::NilComparison + configured with predicate preferred + registers an offense for === nil + registers and corrects an offense when using `x == nil` as a guard condition + registers an offense for == nil + configured with comparison preferred + registers and corrects an offense for `!x.nil?` + registers an offense for nil? -RuboCop::Cop::InternalAffairs::NodeMatcherDirective - registers an offense if the matcher has multiple directives - does not register an offense if the node matcher already has a directive - registers an offense if the matcher does not have a directive - does not register an offense if the directive is in a comment block - does not insert a blank line if one already exists - registers an offense if the matcher does not have a directive and a method call is used for a pattern argument - autocorrects with the right arguments if the pattern references a non-contiguous argument - registers an offense if the matcher does not have a directive but has preceding comments - registers an offense if the matcher does not have a directive but has preceding comments - registers an offense if the directive name does not match the actual name - does not register an offense if the directive is in a comment block - retains indentation properly when inserting - inserts a blank line between multiple multi-line pattern matchers - registers an offense if the matcher does not have a directive - inserts a blank line between multiple multi-line pattern matchers - inserts a blank line between multiple pattern matchers - does not register an offense if the node matcher already has a directive - does not register an offense if called with a dynamic method name - registers an offense if the directive name does not match the actual name - does not register an offense if called with a dynamic method name - retains indentation properly when inserting - inserts a blank line between multiple pattern matchers - autocorrects with the right arguments if the pattern references a non-contiguous argument - retains indentation properly when correcting - registers an offense if the matcher has multiple directives - autocorrects with the right arguments if the pattern includes arguments - registers an offense if the matcher does not have a directive and a method call is used for a pattern argument - does not insert a blank line if one already exists - autocorrects with the right arguments if the pattern includes arguments - retains indentation properly when correcting +RuboCop::Cop::Style::CaseLikeIf + registers an offense and corrects when using `match?` with non regexp in other branches except first + registers an offense and corrects when using `||` within conditions + registers an offense and corrects when using `=~` + does not register an offense when using `match?` without a receiver + does not register an offense when not all conditions contain target + does not register an offense when using `match?` with non regexp + registers an offense and corrects when using `match?` with regexp + does not register an offense when using `unless` + does not register an offense when only single `if` + does not register an offense when using `equal?` without a receiver + registers an offense and corrects when using `==` with constant + does not register an offense when using `match?` in first branch with non regexp + registers an offense and corrects when using `is_a?` + does not register an offense when one of the branches contains `==` with class reference + registers an offense and corrects when using `include?` with range + does not register an offense when an object overrides `equal?` with no arity + registers an offense and corrects when using `===` + does not register an offense when using `cover?` without a receiver + does not register an offense when using `==` with constant containing 1 letter in name + registers an offense and corrects when using nested conditions with `||` + does not register an offense when using `include?` without a receiver + does not register an offense when one of `||` subconditions is not convertible + does not register an offense when only `if-else` + does not register an offense when using ternary operator + does not register an offense when using modifier `if` + does not register an offense when using `=~` in first branch with non regexp + does not register an offense when using `==` with method call with arguments + registers an offense and corrects when target is a method call + does not register an offense when using `==` with class reference + registers an offense and corrects when using `==` with literal + when using regexp with named captures + registers and corrects an offense with =~ and regexp on rhs + does not register an offense with =~ and regexp on lhs + registers and corrects an offense with match? and regexp on lhs + does not register an offense with match and regexp on rhs + registers and corrects an offense with match? and regexp on rhs + does not register an offense with match and regexp on lhs -RuboCop::Cop::Layout::TrailingWhitespace - is not fooled by heredoc containing __END__ - registers an offense for a line ending with space - registers an offense for a line ending with tab - registers an offense for a blank line with space - autocorrects unwanted space - registers offenses before __END__ but not after - is not fooled by heredoc containing __END__ within a doc comment - is not fooled by __END__ within a documentation comment - registers an offense for a tab in a heredoc - accepts a line without trailing whitespace - registers an offense for trailing whitespace in a heredoc string - when `AllowInHeredoc` is set to false - does not correct trailing whitespace in a static heredoc string - corrects a whitespace line in a heredoc string that is longer than the indentation - corrects by removing trailing whitespace used for indentation in a heredoc string - corrects safely trailing whitespace in a heredoc string - when `AllowInHeredoc` is set to true - accepts trailing whitespace in a heredoc string - registers an offense for trailing whitespace at the heredoc begin +RuboCop::Cop::Lint::RefinementImportMethods + Ruby >= 3.1 + registers an offense when using `include` in `refine` block + does not register an offense when using `include` with a receiver in `refine` block + does not register an offense when using `import_methods` in `refine` block + registers an offense when using `prepend` in `refine` block + Ruby <= 3.0 + does not register an offense when using `include` in `refine` block + does not register an offense when using `prepend` in `refine` block -RuboCop::Cop::Style::TrailingBodyOnModule - registers an offense when body trails after module definition - registers offense when module definition uses semicolon - autocorrects with comment after body - autocorrects when there are multiple semicolons - registers offense with multi-line module - accepts regular module - when module is not on first line of processed_source - autocorrects offense +RuboCop::Cop::Style::SelfAssignment + registers an offense for non-shorthand assignment & and @x + registers an offense for non-shorthand assignment ** and @x + registers an offense for non-shorthand assignment + and @@x + registers an offense for non-shorthand assignment || and @@x + registers an offense for non-shorthand assignment + and x + registers an offense for non-shorthand assignment || and @x + registers an offense for non-shorthand assignment - and @@x + registers an offense for non-shorthand assignment * and @x + registers an offense for non-shorthand assignment | and x + registers an offense for non-shorthand assignment | and @@x + registers an offense for non-shorthand assignment - and @x + registers an offense for non-shorthand assignment && and @x + registers an offense for non-shorthand assignment / and @x + registers an offense for non-shorthand assignment && and x + registers an offense for non-shorthand assignment / and x + registers an offense for non-shorthand assignment || and x + registers an offense for non-shorthand assignment ** and @@x + registers an offense for non-shorthand assignment * and x + registers an offense for non-shorthand assignment + and @x + registers an offense for non-shorthand assignment / and @@x + registers an offense for non-shorthand assignment & and x + registers an offense for non-shorthand assignment | and @x + registers an offense for non-shorthand assignment & and @@x + registers an offense for non-shorthand assignment ** and x + registers an offense for non-shorthand assignment * and @@x + registers an offense for non-shorthand assignment - and x + registers an offense for non-shorthand assignment && and @@x -RuboCop::Cop::Lint::TripleQuotes - does not register an offense for implicit concatenation - string interpolation - does not register an offense - with nested extra quotes - registers an offense and corrects - triple quotes - with only whitespace - does not register - on multiple lines - registers an offense and corrects - when only quotes - registers an offense and corrects to a single empty quote - on one line - registers an offense and corrects - heredocs - does not register an offense - quintuple quotes - registers an offense and corrects +RuboCop::Cop::Style::CommentAnnotation + with RequireColon configuration set to false + accepts a keyword that is somewhere in a sentence + accepts a comment that is obviously a code example + accepts upper case keyword with colon, space and note + accepts a keyword that is just the beginning of a sentence + accepts upper case keyword alone + lower case keyword + registers an offense and upcases + upper case keyword with space but no note + registers an offense without autocorrection + offenses in consecutive inline comments + registers each of them + upper case keyword with colon but no note + registers an offense without autocorrection + when a keyword is not in the configuration + accepts the word with colon + multiline comment + only registers an offense on the first line + with configured keyword + registers an offense for containing a colon after the word + with colon + registers an offense and removes colon + with default RequireColon configuration (colon + space) + accepts a comment that is obviously a code example + accepts a keyword that is somewhere in a sentence + accepts a keyword that is just the beginning of a sentence + accepts upper case keyword with colon, space and note + accepts upper case keyword alone + when a keyword is not in the configuration + accepts the word without colon + missing colon + registers an offense and adds colon + capitalized keyword + registers an offense and upcases + missing space after colon + registers an offense and adds space + with configured keyword + registers an offense for a missing colon after the word + upper case keyword with space but no note + registers an offense without autocorrection + with multiword keywords + registers an offense for each matching keyword + lower case keyword + registers an offense and upcases + upper case keyword with colon but no note + registers an offense without autocorrection + offenses in consecutive inline comments + registers each of them + multiline comment + only registers an offense on the first line -RuboCop::Cop::Style::IfWithSemicolon - accepts without `else` branch - can handle modifier conditionals - registers an offense and corrects for one line if/;/end - when elsif is present - accepts with `else` branch - accepts second elsif block - accepts without `else` branch +RuboCop::Cop::Naming::ConstantName + registers 1 offense if rhs is offending const assignment + does not check names if rhs is a method call + registers an offense for snake case in const name + registers offenses for camel case in multiple const assignment + does not check names if rhs is a `Class.new` with conditional assign + does not check names if rhs is a method call with block + does not check if rhs is a non-offensive const assignment + does not check names if rhs is a `Class.new` + allows screaming snake case in multiple const assignment + checks qualified const names + does not check names if rhs is a `Struct.new` + registers an offense for non-POSIX upper case in const name + registers an offense for camel case in const namewhen using frozen object assignment + does not check if rhs is another constant + does not check names if rhs is a `Struct.new` with conditional assign + allows screaming snake case in const name + registers an offense for camel case in const name + does not check names if rhs is a method call with conditional assign + registers an offense for camel case in const namewhen using frozen range assignment + allows screaming snake case with POSIX upper case characters + when a rhs is a conditional expression + when conditional branches contain a value other than a constant + does not check names + when conditional branches contain only constants + does not check names + when conditional branches contain only string values + registers an offense -RuboCop::Cop::Lint::UnusedMethodArgument - when IgnoreNotImplementedMethods config parameter is set - registers an offense for a non-empty method with a single unused parameter - accepts an empty singleton method with a single unused parameter &raise NotImplementedError - accepts a method with a single unused parameter & fails without message - accepts a method with a single unused parameter & fails with message - accepts an empty method with multiple unused parameters - registers an offense for a non-empty method with multiple unused parameters - accepts a method with a single unused parameter & raises NotImplementedError - accepts a method with a single unused parameter & raises ::NotImplementedError - accepts a method with a single unused parameter & raises NotImplementedError, message - inspection - in a method calling `super` without arguments - when a method argument is not used explicitly - accepts since the arguments are guaranteed to be the same as superclass' ones and the user has no control on them - when a singleton method argument is unused +RuboCop::Cop::Metrics::MethodLength + accepts empty methods + accepts a method with multiline arguments and less than 5 lines of body + does not count blank lines + properly counts lines when method ends with block + does not count commented lines by default + accepts a method with less than 5 lines + is not fooled by one-liner methods, syntax #1 + is not fooled by one-liner methods, syntax #2 + when method is defined on a singleton class + registers an offense + when `CountAsOne` is not empty + folds array into one line + when method is defined with `define_method` + registers an offense + when methods to allow are defined + AllowedMethods is enabled + still rejects other methods with more than 5 lines + accepts the foo method with more than 5 lines + AllowedPatterns is enabled + accepts the user_name method + raises offense for firstname + when using numbered parameter + when method is defined with `define_method` registers an offense - when a required keyword argument is unused - when a required keyword argument is unused - registers an offense but does not suggest underscore-prefix - when a splat argument is unused - registers an offense and preserves the splat - when a variable is unused - does not care - when a method takes multiple arguments - and an argument is unused - registers an offense and adds underscore-prefix - and arguments are swap-assigned - accepts - and one argument is assigned to another, whilst other's value is not used - registers an offense - and there is some whitespace around the unused argument - registers an offense and preserves whitespace - and all the arguments are unused - registers offenses and suggests the use of `*` and autocorrects to add underscore-prefix to all arguments - when a trailing block argument is unused - registers an offense and removes the unused block arg - in a method calling `binding` without arguments - accepts all arguments - inside another method definition - registers offenses - when an underscore-prefixed method argument is unused - accepts - when an argument with a default value is unused - registers an offense and preserves the default value - when a method argument is used - accepts - in a method calling `binding` with arguments - when a method argument is unused + when CountComments is enabled + also counts commented lines + when method is a class method + registers an offense + when method is an instance method + registers an offense + +RuboCop::Cop::Style::NumericPredicate + when there are allowed methods + simple method call + `EnforcedStyle` is `comparison` + allows checking if a number is zero + `EnforcedStyle` is `predicate` + allows checking if a number is zero + in argument + not ignored method + when checking if a number is positive + when target ruby version is 2.3 or higher + registers an offense + when target ruby version is 2.2 or lower + does not register an offense + when checking if a number is negative + when target ruby version is 2.3 or higher + registers an offense + when target ruby version is 2.2 or lower + does not register an offense + ignored method + with a string + allows checking if a number is positive + allows checking if a number is negative + with a regex + allows checking if a number is positive + allows checking if a number is negative + in block + not ignored method + registers an offense for checking if a number is positive + registers an offense for checking if a number is negative + ignored method + with a string + allows checking if a number is positive + allows checking if a number is negative + with a regex + allows checking if a number is negative + allows checking if a number is positive + when configured to enforce numeric predicate methods + with checking if a number is not zero + allows comparing against a variable + allows comparing against a complex expression + allows comparing against a global variable + when checking if a number is zero + allows comparing against a global variable + registers an offense with a complex expression + registers an offense + when comparing against a method argument variable registers an offense - in a method calling `super` with arguments - when a method argument is unused + registers an offense with complex expression + when checking if a number is positive + when target ruby version is 2.2 or lower + does not register an offense + when target ruby version is 2.3 or higher + registers an offense in yoda condition registers an offense - when an optional keyword argument is unused - registers an offense but does not suggest underscore-prefix - and AllowUnusedKeywordArguments set - does not care - when a block argument is unused - does not care - when IgnoreEmptyMethods config parameter is set - registers an offense for a non-empty method with multiple unused parameters - accepts an empty method with a single unused parameter - registers an offense for a non-empty method with a single unused parameter - accepts an empty singleton method with a single unused parameter - accepts an empty method with multiple unused parameters - -RuboCop::Cop::Naming::BlockParameterName - can register multiple offenses in one block - does not register offense for valid parameter names - does not register for brace block without parameters - registers offense when param with prefix is less than minimum length - does not register for block without parameters - registers offense when param is less than minimum length - registers offense when param ends in number - registers offense when param contains uppercase characters - with AllowNamesEndingInNumbers - accept params that end in numbers - with AllowedNames - registers unlisted offensive names - accepts specified block param names - with ForbiddenNames - accepts param that uses a forbidden name's letters - registers offense for param listed as forbidden - -RuboCop::Cop::Style::RedundantSort - does not register an offense for sort!.first - does not register an offense when first is used without sort_by - registers an offense when slice(0) is called on sort_by - registers an offense when [0] is called on sort_by - registers an offense when [-1] is called on sort_by - registers an offense when last is called on sort with comparator - registers an offense when first is called on sort_by no block - registers an offense when [](-1) is called on sort_by - does not register an offense when sort has an argument - registers an offense when first is called on sort_by with line breaks and `&&` operator - registers an offense when first is called on sort_by with line breaks - registers an offense when last is called with sort - registers an offense when first is called on sort_by - registers an offense when first is called with sort - registers an offense when last is called on sort_by - does not register an offense when sort_by is used without first - registers an offense when first is called on sort_by with line breaks and `or` operator - registers an offense when [-1] is called on sort - does not register an offense when first has an argument - registers an offense when [](0) is called on sort - registers an offense with `sort_by { a || b }` - registers an offense when first is called on sort_by with line breaks and `||` operator - does not register an offense when first is used before sort - registers an offense when slice(-1) is called on sort_by - registers an offense when at(0) is called on sort_by - registers an offense when at(-1) is called with sort - registers an offense when [0] is called on sort - registers an offense when last is called on sort_by no block - registers an offense when slice(0) is called on sort - does not register an offense for sort_by!(&:something).last - does not register an offense when sort_by is not given a block - registers an offense when first is called on sort_by with line breaks and `and` operator - when not taking first or last element - does not register an offense when [-1] is called on sort with an argument - does not register an offense when at(-2) is called on sort_by - does not register an offense when [1] is called on sort - >= Ruby 2.7 - when using numbered parameter - registers an offense and corrects when at(0) is called on sort_by - registers an offense and corrects when last is called on sort with comparator - registers an offense and corrects when first is called on sort_by + with a complex expression + registers an offense in yoda condition + registers an offense + when checking if a number is negative + when target ruby version is 2.2 or lower + does not register an offense + when target ruby version is 2.3 or higher + registers an offense in yoda condition + registers an offense + with a complex expression + registers an offense + registers an offense in yoda condition + when configured to enforce numeric comparison methods + allows checking if a number is not zero + registers an offense for checking if a number is negative + registers an offense for checking if a number is zero + registers an offense for checking if a number is positive -RuboCop::Cop::Style::EnvHome - does not register an offense when using `ENV.fetch('HOME', default)` - does not register an offense when using `ENV['HOME'] = '/home/foo'` - registers and corrects an offense when using `ENV.fetch('HOME', nil)` - registers and corrects an offense when using `ENV.fetch('HOME')` - does not register an offense when using `Dir.home` - registers and corrects an offense when using `::ENV['HOME']` - registers and corrects an offense when using `ENV['HOME']` +RuboCop::Cop::Style::Documentation + accepts non-empty module with documentation + registers an offense for a deeply nested class + registers an offense for non-namespace + accepts namespace module which defines constants + registers an offense for non-empty class with encoding comment + registers an offense for non-empty class with directive comment + registers an offense for compact-style nested class + registers an offense for non-empty class + accepts namespace class without documentation + registers an offense for empty module without documentation + accepts non-empty class with documentation + registers an offense for non-empty cbase class + accepts non-empty class with annotation comment followed by other comment + accepts namespace class which defines constants + registers an offense for compact-style nested module + registers an offense for non-empty class with annotation comment + does not raise an error for an implicit match conditional + accepts non-empty class with comment that ends with an annotation + accepts empty class without documentation + accepts namespace module without documentation + registers offense for non-empty class with frozen string comment + does not consider comment followed by empty line to be class documentation + registers an offense if the comment line contains code + sparse and trailing comments + ignores sparse comments inside module node + ignores comments after module node end + ignores sparse comments inside class node + ignores comments after class node end + with # :nodoc: + registers an offense for nested class without documentation + registers an offense for nested module without documentation + accepts non-namespace module without documentation + accepts non-namespace class without documentation + accepts compact-style nested module without documentation + accepts compact-style nested class without documentation + with `all` modifier + accepts nested module without documentation + on a subclass + registers an offense for nested subclass without documentation + accepts non-namespace subclass without documentation + with `all` modifier + accepts nested subclass without documentation + when AllowedConstants is configured + ignores the constants in the config + with `all` modifier + accepts nested class without documentation + without documentation + macro-only class + does not register offense with multiple macros + does not register offense with single macro + registers offense for macro with other methods + with non-empty class + with constants visibility declaration content + does not register an offense + with non-empty module + with constants visibility declaration content + does not register an offense -RuboCop::FeatureLoader - .load - with unexpected LoadError from require - raises LoadError - with namespaced feature - loads it as namespaced feature - with dot-prefixed namespaced feature - loads it as namespaced feature - with normally loadable feature - loads it normally - with dot-prefixed loadable feature - loads it as relative path - with unloadable namespaced feature - raises LoadError with preferred message +RuboCop::Cop::Style::MultilineWhenThen + does not register an offense when line break for multiple candidate values of `when` + autocorrects when the body of `when` branch starts with `then` + doesn't register an offense when `then` required for a body of `when` is used + does not register an offense for array when statement with then + registers an offense when one line for multiple candidate values of `when` + doesn't register an offense for multiline when statementwith then followed by other lines + doesn't register an offense for multiline when statement without then + doesn't register an offense for empty when statement without then + registers an offense for multiline (two lines in a body) when statement with then + registers an offense for empty when statement with then + registers an offense for multiline (one line in a body) when statement with then + does not register an offense for hash when statement with then + doesn't register an offense for singleline when statement with then -RuboCop::Cop::Lint::OrAssignmentToConstant - does not register an offense with or-assignment to a local variable - does not register an offense with plain assignment to a constant - does not register an offense with or-assignment to a class variable - does not register an offense with or-assignment to a global variable - does not register an offense with or-assignment to an attribute - does not register an offense with or-assignment to an instance variable - registers an offense with or-assignment to a constant +RuboCop::Cop::Gemspec::DuplicatedAssignment + does not register an offense when `name=` method call is not block value + registers an offense when using `required_ruby_version=` twice + registers an offense when using `name=` twice with `cbase` + does not register an offense when using `<<` twice + registers an offense when using `version=` twice + registers an offense when using `name=` twice + does not register an offense when using `spec.add_dependency` twice -RuboCop::Cop::Style::TrailingUnderscoreVariable - configured to not allow named underscore variables - does not register an offense when there are no underscores - does not register an offense for complex nested assignments without trailing underscores - registers an offense when underscore is the second to last variable and blank is the last variable - registers an offense for nested assignments with trailing underscores - does not register an offense for underscores at the beginning - registers an offense when multiple underscores are used as the last variables of parallel assignment - registers an offense for multiple underscore variables preceded by a named splat underscore variable - does not register an offense for an underscore preceded by a splat variable anywhere in the argument chain - registers an offense for named variables that start with an underscore - does not register an offense for nested assignments without trailing underscores - does not register an offense for a named underscore variable preceded by a splat variable - does not register an offense for a named variable preceded by a names splat underscore variable - registers an offense for an underscore as the last param when there is also an underscore as the first param - does not register an offense for an underscore preceded by a splat variable and another underscore - does not register an offense for an underscore preceded by a splat variable - registers an offense for multiple underscore variables preceded by a splat underscore variable - does not register an offense for multiple underscores preceded by a splat variable - registers an offense for an underscore preceded by a named splat underscore - registers an offense when underscore is the only variable in parallel assignment - registers an offense for splat underscore as the last variable - does not register an offense for multiple named underscores preceded by a splat variable - registers an offense for a named splat underscore as the last variable - registers an offense when the last variable of parallel assignment is an underscore - registers an offense for an underscore variable preceded by a named splat underscore variable - registers an offense for complex nested assignments with trailing underscores - does not register an offense for a named underscore preceded by a splat variable - autocorrect - with parentheses - leaves parentheses but removes trailing underscores - removes assignment part when it is the only variable - leaves parentheses but removes trailing underscores and commas - removes assignment part when every assignment is to `_` - configured to allow named underscore variables - does not register an offense for multiple underscore variables preceded by a named splat underscore variable - registers an offense for complex nested assignments with trailing underscores - registers an offense when multiple underscores are used as the last variables of parallel assignment - does not register an offense for complex nested assignments without trailing underscores - registers an offense when underscore is the only variable in parallel assignment - does not register an offense for nested assignments without trailing underscores - does not register an offense for underscores at the beginning - registers an offense for multiple underscore variables preceded by a splat underscore variable - registers an offense when underscore is the second to last variable and blank is the last variable - registers an offense for an underscore as the last param when there is also an underscore as the first param - does not register an offense for an underscore preceded by a splat variable - does not register an offense for an underscore preceded by a splat variable anywhere in the argument chain - does not register an offense for an underscore preceded by a splat variable and another underscore - does not register an offense for a named variable preceded by a names splat underscore variable - does not register an offense when there are no underscores - registers an offense for splat underscore as the last variable - does not register an offense for a named underscore variable preceded by a splat variable - registers an offense for nested assignments with trailing underscores - does not register an offense for multiple underscores preceded by a splat variable - registers an offense when the last variable of parallel assignment is an underscore - does not register an offense for multiple named underscores preceded by a splat variable - does not register an offense for a named splat underscore as the last variable - does not register an offense for named variables that start with an underscore - does not register an offense for an underscore variable preceded by a named splat underscore variable - autocorrect - with parentheses - removes assignment part when it is the only variable - leaves parentheses but removes trailing underscores and commas - leaves parentheses but removes trailing underscores - removes assignment part when every assignment is to `_` +RuboCop::Cop::Style::HashLikeCase + MinBranchesCount: 2 + does not register an offense when `case` has an `else` branch + does not register an offense when using `case-when` with literal bodies of different types + registers an offense when using `case-when` with symbol conditions and literal bodies of the same type + does not register an offense when using `case-when` with non-literal bodies + does not register an offense when using `case-when` with non-literals in conditions + registers an offense when using `case-when` with string conditions and literal bodies of the same type + does not register an offense when using `case-when` with literals of different types as conditions + MinBranchesCount: 3 + does not register an offense when branches count is less than required -RuboCop::Cop::Layout::IndentationStyle - when EnforcedStyle is spaces - accepts a line with tab in a string - registers offenses before __END__ but not after - registers and corrects an offense for a line indented with mixed whitespaces - registers and corrects an offense for a line with tab in a string indented with tab - accepts a line with a tab other than indentation - accepts a line which begins with tab in a string - accepts a line which begins with tab in a heredoc - registers and corrects an offense for a line indented with multiple tabs - registers and corrects an offense for a line indented with tab - accepts a line with a tab between string literals - accepts a line which begins with tab in a multiline heredoc - custom indentation width - uses the configured number of spaces to replace a tab - when EnforcedStyle is tabs - accepts a line which begins with tab in a string - registers offenses before __END__ but not after - accepts a line which begins with tab in a heredoc - registers and corrects an offense for a line indented with fractional number ofindentation groups by rounding down - accepts a line with tabs between string literals - accepts a line which begins with tab in a multiline heredoc - accepts a line a tab other than indentation - accepts a line with tab in a string - registers and corrects an offense for a line with tab in a string indented with space - registers an offense for a line indented with mixed whitespace - registers and corrects an offense for a line indented with space - registers and corrects an offense for a line indented with multiple spaces - custom indentation width - uses the configured number of spaces to replace with a tab +RuboCop::Formatter::PacmanFormatter + #next_step + when no offenses are detected + calls the step function with a dot + when a offense is detected in a file + calls the step function with a dot + #update_progress_line + when total_files is greater than columns in the terminal + updates the progress_line properly + when need to change the line + updates the progress_line properly + when total_files less than columns in the terminal + updates the progress_line properly + #step + character is Pacman + removes the first • and puts a ᗧ + character is normal dot + removes the first • and puts a . + character is ghost + removes the first • and puts a ghosts + character is a Pacdot + leaves the progress_line as it is -RuboCop::Cop::Layout::EmptyLinesAroundClassBody - when EnforcedStyle is empty_lines_special - class with empty body - with empty line - does NOT register offenses - without empty line - does NOT register offenses - class with only constants - registers and autocorrects the offenses - class with constant and child class - registers and autocorrects the offenses - when first child is NOT a method - does not require blank line at the beginning of class body but requires blank line before first def definition and requires blank line at the end of class body - source with blank lines - registers an offense for class beginning with a blank line - source without blank lines - registers an offense for class not ending with a blank line - source with comment before method definition - registers an offense for class beginning with a blank line - when class has a namespace - requires no empty lines for namespace and does not require blank line at the beginning of class body but requires blank line at the end of class body - source without blank lines - registers and autocorrects the offenses - source with constants - registers and autocorrects the offenses - source with blank lines - registers and autocorrects the offenses - when namespace has multiple children - requires empty lines for namespace - when first child is a method - requires blank line at the beginning and ending of class body - source without blank lines - registers an offense for class not beginning and ending with a blank line - when class has a namespace - requires no empty lines for namespace but requires blank line at the beginning and ending of class body - source without blank lines - registers and autocorrects the offenses - source with blank lines - autocorrects the offenses - when first child is an access modifier - with blank lines at the beginning and ending of class body - registers no offense - with no blank lines at the beginning and ending of class body - registers and corrects an offense - when EnforcedStyle is ending_only - registers an offense for an empty line at the end of a class - ignores empty lines at the beginning of a class - when EnforcedStyle is empty_lines - does not register offenses when specifying a superclass that breaks the line - does not register offenses - accepts singleton classes with an empty body - registers an offense for singleton class body not starting or ending with a blank - registers an offense for class body not starting or ending with a blank - accepts classes with an empty body - when EnforcedStyle is empty_lines_except_namespace - when only child is module - requires no empty lines for namespace - registers offense for namespace body ending with a blank - registers offense for namespace body starting with a blank - when only child is class - registers offenses for namespaced class body not ending with a blank - registers offense for namespace body starting with a blank - requires no empty lines for namespace - registers offenses for namespaced class body not starting with a blank - registers offense for namespace body ending with a blank - autocorrects beginning and end - when has multiple child classes - requires empty lines for namespace - registers offenses for namespace body starting and ending without a blank - when EnforcedStyle is beginning_only - registers an offense for an empty line at the end of a class - ignores empty lines at the beginning of a class - when EnforcedStyle is no_empty_lines - registers an offense for singleton class body ending with a blank - autocorrects singleton class body containing only a blank - registers an offense for class body ending with a blank - registers an offense for class body starting with a blank +RuboCop::Cop::Lint::UriEscapeUnescape + registers an offense when using `::URI.decode(enc_uri)` + registers an offense when using `URI.decode(enc_uri)` + registers an offense when using `URI.escape('@?@!', '!?')` + registers an offense when using `::URI.escape('http://example.com')` + registers an offense when using `URI.unescape(enc_uri)` + registers an offense when using `URI.encode('http://example.com')` + registers an offense when using `::URI.unescape(enc_uri)` + registers an offense when using `URI.escape('http://example.com')` + registers an offense when using `::URI.encode('http://example.com)` RuboCop::Cop::Style::SymbolProc + accepts empty block body + accepts lambda with 1 argument accepts a block with an unused argument with an method call - does not register an offense when receiver is a hash literal and using `select` with a block - accepts block with a block argument - registers an offense for a block when method in body is unary -/+ - registers an offense for safe navigation operator - registers an offense when receiver is an array literal and using `select` with a block - registers an offense when receiver is a hash literal and using `max` with a block - accepts block when method in body is not called on block arg - accepts ::Proc.new with 1 argument + accepts a block with an unused argument with an lvar + registers an offense when receiver is an array literal and using `reject` with a block autocorrects multiple aliases with symbols as proc - accepts block with no arguments accepts block with splat params - accepts proc with 1 argument - accepts a block with an unused argument with an lvar - does not crash with a bare method call - does not register an offense when receiver is a array literal and using `min` with a block accepts block with adding a comma after the sole argument + accepts block with no arguments accepts block with more than 1 arguments - does not register an offense when receiver is a array literal and using `max` with a block - registers an offense for a block with parameterless method call on param - autocorrects correctly when there are no arguments in parentheses + accepts block when method in body is not called on block arg + does not register an offense when receiver is a array literal and using `min` with a block + accepts ::Proc.new with 1 argument accepts block with more than 1 expression in body - registers an offense when receiver is some value and using `reject` with a block + registers an offense for a block with parameterless method call on param + does not register an offense when receiver is a hash literal and using `select` with a block + does not crash with a bare method call registers an offense when receiver is a hash literal and using `min` with a block autocorrects correctly when args have a trailing comma - registers an offense when receiver is an array literal and using `reject` with a block - accepts empty block body accepts Proc.new with 1 argument - registers an offense when receiver is some value and using `select` with a block - accepts lambda with 1 argument + registers an offense for safe navigation operator + accepts block with a block argument + autocorrects correctly when there are no arguments in parentheses + registers an offense when receiver is a hash literal and using `max` with a block + registers an offense when receiver is an array literal and using `select` with a block + registers an offense when receiver is some value and using `reject` with a block + accepts proc with 1 argument + does not register an offense when receiver is a array literal and using `max` with a block + registers an offense for a block when method in body is unary -/+ does not register an offense when receiver is a hash literal and using `reject` with a block - AllowComments: true - registers an offense for a block with parameterless method call on paramand not contains a comment - accepts block with parameterless method call on param and contains a comment + registers an offense when receiver is some value and using `select` with a block + when AllowedPatterns is enabled + accepts ignored method when AllowedMethods is enabled accepts ignored method + when the method has arguments + registers an offense + when `AllowMethodsWithArguments: true` + when method has arguments + does not register an offense + when `super` has arguments + does not register an offense + when method has no arguments + registers an offense numblocks + accepts Proc.new with 1 numbered parameter registers an offense when receiver is an hash literal and using `max` with a numblock + does not register an offense when receiver is a array literal and using `min` with a numblock registers an offense when receiver is an hash literal and using `min` with a numblock does not register an offense when receiver is a array literal and using `max` with a numblock - accepts ::Proc.new with 1 numbered parameter + registers an offense when receiver is some value and using `reject` with a numblock + accepts lambda with 1 numbered parameter registers an offense when receiver is an array literal and using `reject` with a numblock - accepts block with only second numbered parameter - accepts block with multiple numbered parameters - registers an offense when receiver is an array literal and using `select` with a numblock registers an offense for a block with a numbered parameter - does not register an offense when receiver is a array literal and using `min` with a numblock - does not register an offense when receiver is a hash literal and using `reject` with a numblock - registers an offense when receiver is some value and using `reject` with a numblock - accepts Proc.new with 1 numbered parameter + accepts block with only second numbered parameter does not register an offense when receiver is a hash literal and using `select` with a numblock accepts proc with 1 numbered parameter + does not register an offense when receiver is a hash literal and using `reject` with a numblock + accepts ::Proc.new with 1 numbered parameter + accepts block with multiple numbered parameters + registers an offense when receiver is an array literal and using `select` with a numblock registers an offense when receiver is some value and using `select` with a numblock - accepts lambda with 1 numbered parameter - when `AllowMethodsWithArguments: true` + when `AllowMethodsWithArguments: false` when method has arguments - does not register an offense - when method has no arguments registers an offense when `super` has arguments - does not register an offense - when `super` has no arguments - registers an offense - when `AllowMethodsWithArguments: false` - when `super` has arguments registers an offense - when method has arguments - registers an offense - when AllowedPatterns is enabled - accepts ignored method - when the method has arguments - registers an offense - -RuboCop::Cop::Lint::NoReturnInBeginEndBlocks - accepts a block with no return when using += - rejects a return statement inside a block when using ||= - accepts a block with no return when using ||= - accepts a block with no return when using *= - rejects a return statement inside a block when using *= - rejects a return statement inside a block when using /= - accepts a block with no return when using = - accepts a block with no return when using **= - rejects a return statement inside a block when using += - rejects a return statement inside a block when using = - rejects a return statement inside a block when using **= - rejects a return statement inside a block when using -= - accepts a block with no return when using /= - accepts a block with no return when using -= - -RuboCop::Cop::Style::ArgumentsForwarding - TargetRubyVersion <= 2.6 - does not register an offense when using restarg with block arg - TargetRubyVersion >= 3.1 - registers an offense when using restarg, kwargs, and anonymous block arg - registers an offense when using restarg and anonymous block arg - TargetRubyVersion >= 2.7 - does not register an offense when body of method definition is empty - registers an offense when using restarg, kwargs and block arg - does not register an offense when using arguments forwarding - does not register an offense when using the restarg outside forwarding method arguments - registers an offense when delegating - does not register an offense when assigning the restarg outside forwarding method arguments - registers an offense when using restarg and block arg - registers an offense when passing restarg and block arg in defs - registers an offense when forwarding to a method in block - registers an offense when the parentheses of arguments are omitted - does not register an offense when referencing the restarg outside forwarding method arguments - does not register an offense when the block arg is overwritten - does not register an offense when different arguments are used - does not register an offense when the restarg is overwritten - does not register an offense when different argument names are used - does not register an offense when the kwarg is overwritten - AllowOnlyRestArgument: true - does not register an offense when using only rest arg - does not register an offense when using only kwrest arg - AllowOnlyRestArgument: false - registers an offense when using only kwrest arg - registers an offense when using only rest arg - -RuboCop::Cop::Lint::EmptyClass - does not register an offense when empty has a parent - registers an offense for empty class - registers an offense when empty metaclass contains only comments - registers an offense for empty class metaclass - does not register an offense when metaclass is not empty - registers an offense for empty object metaclass - does not register an offense when class is not empty - when AllowComments is true - does not register an offense when empty metaclass contains only comments - does not register an offense when empty class contains only comments - -RuboCop::Cop::Lint::Loop - registers an offense and corrects for begin/end/while - accepts loop/break if - registers an offense for begin/end/until - accepts loop/break unless - -RuboCop::Cop::Lint::AmbiguousAssignment - registers an offense when using `!` with `X` - registers an offense when using `-` with `$x` - registers an offense when using `*` with `$x` - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - registers an offense when using `*` with `X` - does not register an offense when no mistype assignments - registers an offense when using `+` with `@@x` - registers an offense when using `-` with `@x` - does not register an offense when no mistype assignments - registers an offense when using `+` with `@x` - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - registers an offense when using `*` with `x` - registers an offense when using `!` with `x` - does not register an offense when no mistype assignments - registers an offense when using `+` with `$x` - does not register an offense when no mistype assignments - registers an offense when using `!` with `@x` - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - registers an offense when using `*` with `@@x` - registers an offense when using `-` with `X` - registers an offense when using `+` with `x` - does not register an offense when no mistype assignments - registers an offense when using `+` with `X` - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - does not register an offense when no mistype assignments - registers an offense when using `!` with `@@x` - registers an offense when using `*` with `@x` - registers an offense when using `!` with `$x` - does not register an offense when no mistype assignments - registers an offense when using `-` with `@@x` - registers an offense when using `-` with `x` - does not register an offense when no mistype assignments - -RuboCop::Cop::Style::FetchEnvVar - registers an offense with using an `ENV` at multiple `if` condition in the body - registers an offense when using an `ENV` at `if` condition in the body - registers an offense when using `ENV || x` that is different from `if` condition in the body - registers an offense when using `ENV && x` that is different from `if` condition in the body - when it is evaluated with no default values - registers an offense - when it is compared `==` with other object - does not register an offense - when it is assigned to a variable - registers an offense when using single assignment - registers an offense when using multiple assignment - when it is a hash value - registers an offense - when using `fetch` instead of `[]` - registers no offenses - when `ENV[]` is the right end of `||` chains - registers an offense - when it is compared `!=` with other object - does not register an offense - when it is used in an interpolation - registers an offense - when the node is a assigned by `&&=` - registers an offense - when it is an array element - registers an offense - when the node is a receiver of `||=` - does not register an offense - when `ENV[]` is the LHS of `||` - registers no offenses - when it receives a message with safe navigation - registers no offenses - when the node is a receiver of `&&=` - does not register an offense - when it is a hash key - registers an offense - with negation - registers no offenses - when it receives a message - registers no offenses - when it is an argument of a method - registers an offense - when it is used in a conditional expression - registers an offense when using an `ENV` var that is different from `if` condition in the body - registers no offenses with ternary operator - registers an offense with `case` - registers an offense with using an `ENV` var as `if` condition in the body with assignment method - registers no offenses when using the same `ENV` var as `if` condition in the body with operator - registers no offenses with `unless` - registers no offenses when using the same `ENV` var as `if` condition in the body with predicate method - registers no offenses when using the same `ENV` var as `if` condition in the body with other conditions - registers no offenses when using the same `ENV` var as `if` condition in the body with assignment method - registers no offenses when using the same `ENV` var as `if` condition in the body - registers no offenses with `if` - when the env val is excluded from the inspection by the config - registers no offenses - when the node is a assigned by `||=` + when `super` has no arguments registers an offense + AllowComments: true + accepts block with parameterless method call on param and contains a comment + registers an offense for a block with parameterless method call on paramand not contains a comment -RuboCop::Cop::Style::RedundantReturn - accepts return in a non-final position - reports an offense for def ending with return - does not blow up on empty method body - reports an offense for defs with only a return - does not blow up on empty if body - autocorrects by removing redundant returns - reports an offense for defs ending with return - reports an offense for def with only a return - reports an offense for def ending with return with splat argument - when multi-value returns are allowed - accepts defs ending with return - accepts def with only a return - accepts defs with only a return - accepts def ending with return - when return is inside an if-branch - registers an offense and autocorrects - when return has no arguments - behaves like common behavior - registers an offense for return() and autocorrects replacing return() with nil - behaves like common behavior - registers an offense for return and autocorrects replacing return with nil - when return is inside begin-end body - registers an offense and autocorrects - when return is inside a when-branch - registers an offense and autocorrects - when rescue and return blocks present - registers an offense and autocorrects when rescue has else clause - registers an offense and autocorrects when inside function or rescue block - when multi-value returns are not allowed - reports an offense for defs with only a return - reports an offense when multiple return values have a parenthesized return value - autocorrects by making an implicit hash explicit - reports an offense for defs ending with return - reports an offense for def ending with return - reports an offense for def with only a return - autocorrects by removing return when using an explicit hash - when case nodes are empty - accepts empty when nodes - -RuboCop::Cop::Layout::LineContinuationLeadingSpace - EnforcedStyle: trailing - registers offenses when 2nd and 3rd line has leading spaces - puts the offense message in correct position also on indented line - registers offense in the right location when 1st line is not the string - registers an offense when 2nd line has one leading space - marks the correct range when string is a block method argument - marks the correct range when string is a positional method argument - registers an offense when 2nd line has multiple leading spaces - interpolated strings - registers offenses when 2nd line has leading spaces and 2nd line is interpolated - registers no offense for correctly formatted multiline interpolated string - registers no offense on interpolated string alone - registers offenses when 2nd line has leading spaces and 1st line is interpolated - registers an offense for incorrectly formatted multiline interpolated string - registers no offense on doubly interpolated string alone - registers no offense for correctly formatted multiline interpolation - EnforcedStyle: leading - registers offenses when 1st and 2nd line has trailing spaces - marks the correct range when string is a block method argument - registers offense in the right location when 1st line is not the string - marks the correct range when string is a positional method argument - registers an offense when 1st line has one trailing space - registers an offense when 1st line has multiple trailing spaces - puts the offense message in correct position also on indented line - interpolated strings - registers no offense for correctly formatted multiline interpolated string - registers offenses when 1st line has leading spaces and 1st line is interpolated - registers no offense on doubly interpolated string alone - registers an offense for incorrectly formatted multiline interpolated string - registers no offense on interpolated string alone - registers offenses when 1st line has trailing spaces and 2nd line is interpolated - registers no offense for correctly formatted multiline interpolation - -RuboCop::Cop::Style::IfWithBooleanLiteralBranches - when condition is a comparison method - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using ternary operator with boolean literal branches - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - does not register an offense when using a branch that is not boolean literal - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `if foo == bar` with boolean literal branches - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `unless foo == bar` with boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using opposite ternary operator with boolean literal branches - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using `if foo == bar` with boolean literal branches - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - registers and corrects an offense when using ternary operator with boolean literal branches - does not register an offense when using a branch that is not boolean literal - registers and corrects an offense when using `if` with boolean literal branches directly under `def` - registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches - when using `elsif` with boolean literal branches - registers and corrects an offense when using single `elsif` with boolean literal branches - does not register an offense when using multiple `elsif` with boolean literal branches - when `AllowedMethods: nonzero?` - does not register an offense when using `nonzero?` - when condition is a predicate method - registers and corrects an offense when using `if foo.do_something?` with boolean literal branches - registers and corrects an offense when using `unless foo.do_something?` with opposite boolean literal branches - registers and corrects an offense when using `unless foo.do_something?` with boolean literal branches - registers and corrects an offense when using `if foo.do_something?` with opposite boolean literal branches - registers and corrects an offense when using `elsif foo.do_something?` with opposite boolean literal branches - registers and corrects an offense when using `elsif foo.do_something?` with boolean literal branches - when condition is a logical operator and operands do not known whether to return boolean value - does not register an offense when using `if foo && bar` with opposite boolean literal branches - does not register an offense when using `unless foo && bar` with boolean literal branches - does not register an offense when using `if foo || bar` with boolean literal branches - does not register an offense when using `unless foo || bar` with boolean literal branches - does not register an offense when using `unless foo || bar` with opposite boolean literal branches - does not register an offense when using `unless foo && bar` with opposite boolean literal branches - does not register an offense when using `if foo && bar` with boolean literal branches - does not register an offense when using `if foo || bar` with opposite boolean literal branches - when condition is a logical operator and all operands are predicate methods - registers and corrects an offense when using `unless foo? || bar?` with opposite boolean literal branches - registers and corrects an offense when using `if foo? && bar?` with opposite boolean literal branches - registers and corrects an offense when using `unless foo? || bar?` with boolean literal branches - registers and corrects an offense when using `if foo? && bar? || baz?` with boolean literal branches - registers and corrects an offense when using `if foo? && bar? && baz?` with boolean literal branches - registers and corrects an offense when using `if foo? && bar?` with boolean literal branches - when condition is a method that does not known whether to return boolean value - does not register an offense when using `unless condition` with opposite boolean literal branches - does not register an offense when using `if condition` with boolean literal branches - does not register an offense when using `unless condition` with boolean literal branches - does not register an offense when using `if condition` with opposite boolean literal branches - when complex condition - does not register an offense when using `if foo? || bar || baz?` with boolean literal branches - register and corrects an offense when using `if (foo? || bar) && baz?` with boolean literal branches - registers and corrects an offense when using `if foo? || (bar && baz)?` with boolean literal branches - does not register an offense when using `if foo? && bar || baz?` with boolean literal branches - registers and corrects an offense when using `if foo? || bar && baz?` with boolean literal branches - does not register an offense when using `if (foo? && bar) || baz?` with boolean literal branches - does not register an offense when using `if foo? && (bar || baz)?` with boolean literal branches - registers and corrects an offense when using `if foo? && bar && baz?` with boolean literal branches - when double negative is used in condition - registers and corrects an offense when using `if !!condition` with boolean literal branches - registers and corrects an offense when using `if !!condition` with opposite boolean literal branches - -RuboCop::Cop::Lint::DuplicateElsifCondition - registers an offense for subsequent repeated elsif conditions - registers an offense for repeated elsif conditions - does not register an offense for non-repeated elsif conditions - registers multiple offenses for multiple repeated elsif conditions - does not register an offense for partially repeated elsif conditions - -RuboCop::Cop::Layout::EmptyLinesAroundModuleBody - when EnforcedStyle is empty_lines_except_namespace - when only child is class - registers offense for namespace body ending with a blank - requires no empty lines for namespace - registers offense for namespace body starting with a blank - when only child is module - requires no empty lines for namespace - registers offense for namespace body starting with a blank - registers offenses for namespaced module body not starting with a blank - autocorrects beginning and end - registers offense for namespace body ending with a blank - registers offenses for namespaced module body not ending with a blank - when has multiple child modules - registers offenses for namespace body starting and ending without a blank - requires empty lines for namespace - when EnforcedStyle is empty_lines - accepts modules with an empty body - autocorrects beginning and end - registers an offense for module body not starting or ending with a blank - registers an offense for module body not ending with a blank - when EnforcedStyle is empty_lines_special - when first child is a method - requires blank line at the beginning and ending of module body - source without blank lines - registers an offense for module not beginning and ending with a blank line - when module has a namespace - requires no empty lines for namespace but requires blank line at the beginning and ending of module body - source with blank lines - autocorrects the offenses - source without blank lines - registers and autocorrects the offenses - module with empty body - with empty line - does NOT register offenses - without empty line - does NOT register offenses - module with constant and child module - registers and autocorrects the offenses - when first child is NOT a method - does not require blank line at the beginning of module body but requires blank line before first def definition and requires blank line at the end of module body - source without blank lines - registers an offense for module not ending with a blank line - when module has a namespace - requires no empty lines for namespace and does not require blank line at the beginning of module body but requires blank line at the end of module body - source without blank lines - registers and autocorrects the offenses - source with blank lines - registers and autocorrects the offenses - source with constants - registers and autocorrects the offenses - source with blank lines - registers an offense for module beginning with a blank line - source with comment before method definition - registers an offense for module beginning with a blank line - when first child is an access modifier - with no blank lines at the beginning and ending of module body - registers and corrects an offense - with blank lines at the beginning and ending of module body - registers no offense - when namespace has multiple children - requires empty lines for namespace - module with only constants - registers and autocorrects the offenses - when EnforcedStyle is no_empty_lines - registers an offense for module body ending with a blank - registers an offense for module body starting with a blank - autocorrects beginning and end - -RuboCop::Cop::Lint::ElseLayout - registers and corrects an offense when using multiple `elsif`s - accepts proper else - registers an offense and corrects for elsifs - accepts empty braces - registers an offense and corrects for the entire else body being on the same line - accepts modifier forms - does not register an offense if the entire if is on a single line - registers an offense and corrects for expr on same line as else - does not register an offense for an elsif with no body - accepts ternary ops - -RuboCop::Cop::Style::TrivialAccessors - registers an offense on writer without braces - accepts writer with different ivar name - accepts non-trivial writer - accepts an initialize method looking like a writer - accepts reader with different ivar name - accepts writer nested within an instance_eval call - accepts reader using top level - registers an offense on reader with braces - accepts expressions within writer - accepts splats - registers an offense on class reader - registers an offense on instance reader - accepts writer using top level - registers an offense on reader with `private` - accepts writer nested within a module - accepts non-trivial reader - accepts writer in a module - does not register an offense on DSL-style writer - registers an offense on one-liner writer - registers an offense on instance writer - registers an offense on class writer - accepts expressions within reader - accepts reader nested within a module - accepts blocks - accepts reader nested within an instance_eval call - registers an offense on one-liner reader - flags a reader inside a class, inside an instance_eval call - with allowed methods - accepts allowed reader - accepts allowed writer - with AllowPredicates: false - accepts allowed predicate - exact name match disabled - registers an offense when names mismatch in reader - registers an offense when names mismatch in writer - ignore class methods - accepts class writer - accepts class reader - with DSL denied - registers an offense on DSL-style writer - allow predicates - accepts predicate-like reader - disallow predicates - does not accept predicate-like reader - -RuboCop::Cop::Lint::EmptyConditionalBody - registers an offense for missing second `elsif` body without an inline comment - autocorrects properly when the if is assigned to a variable - registers an offense for missing all branches of `if` and `elsif` body - does not register an offense for missing `elsif` body with a comment - registers an offense for missing `if` body with `else` - registers an offense for missing `unless` body with `else` - registers an offense for missing `if` and `else` body with some indentation - registers an offense for missing `elsif` body - registers an offense for missing `unless` and `else` body - registers an offense for missing `if` and `elsif` body - registers an offense for missing `if` body with `elsif` - registers an offense for missing `unless` body - registers an offense for missing `if` and `else` body - registers an offense for missing all branches of `if` and multiple `elsif` body - registers an offense for missing `elsif` body that is not the one with a comment - registers an offense for missing `if` body with present `else` body - does not register an offense for missing `if` body with a comment - registers an offense for missing `if` body - does not register an offense for missing `elsif` body with an inline comment - does not register an offense for missing `unless` body with a comment - when AllowComments is false - registers an offense for missing `elsif` body with a comment - registers an offense for missing `unless` body with a comment - registers an offense for missing `if` body with a comment - -RuboCop::Cop::Style::EachForSimpleLoop - does not register offense for character range - does not register offense if range endpoint is not constant - does not register offense if range startpoint is not constant - when using an exclusive end range - does not register offense for range not starting with zero and using param - autocorrects the source with inline block - autocorrects the range not starting with zero - autocorrects the source with multiline block - with inline block with parameters - autocorrects an offense - with multiline block with parameters - autocorrects an offense - when using an inclusive end range - autocorrects the source with multiline block - autocorrects the source with inline block - autocorrects the range not starting with zero - does not register offense for range not starting with zero and using param - -RuboCop::Cop::Style::ImplicitRuntimeError - does not register an offense for `fail` without arguments - does not register an offense for `fail` with an error class - registers an offense for `fail` with a multiline string - does not register an offense for `raise` without arguments - registers an offense for `raise` without error class - does not register an offense for `raise` with an error class - registers an offense for `raise` with a multiline string - registers an offense for `fail` without error class - -RuboCop::Cop::Lint::RequireRelativeSelfPath - registers an offense when using `require_relative` with self file path argument - does not register an offense when using `require_relative` without argument - does not register an offense when using `require_relative` without self file path argument - does not register an offense when using a variable as an argument of `require_relative` - registers an offense when using `require_relative` with self file path argument (with ext) - does not register an offense when the filename is the same but the extension does not match - -Changelog - parses correctly - merges correctly - Changelog::Entry - #ref_id - when there is an issue referenced with [Fixes #x] the body - is expected to eq "123" - when there is no issue referenced in the body - is expected to eq "x" - when there is an issue referenced with [Fix #x] the body - is expected to eq "123" - when there is no body - is expected to eq "x" - #content - when there is an issue referenced - generates correct content - when there is no issue referenced - generates correct content - #body - when there is an issue referenced with [Fixes #x] the body - is expected to eq "Fix something" - when there is an issue referenced with [Fix #x] the body - is expected to eq "Fix something" - when there is no body - is expected to eq "" - when there is no issue referenced in the body - is expected to eq "Fix something" - -RuboCop::Cop::Naming::ClassAndModuleCamelCase - is not fooled by qualified names - accepts CamelCase names - registers an offense for underscore in class and module name - allows module_parent method - custom allowed names - does not register offense for multiple allowed names - -RuboCop::Cop::Style::AccessModifierDeclarations - when `inline` is configured - offends when module_function is not inlined - does not offend when public is inlined with a method - does not offend when private is inlined with a symbol - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - offends when protected is not inlined and has a comment - offends when public is not inlined and has a comment - accepts when #{access_modifier} is a hash literal value - accepts when #{access_modifier} is a hash literal value - does not offend when protected is inlined with a symbol - does not offend when private is inlined with a method - does not offend when protected is inlined with a method - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - does not offend when module_function is inlined with a symbol - offends when public is not inlined - does not offend when public is inlined with a symbol - offends when private is not inlined - offends when protected is not inlined - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - does not offend when module_function is inlined with a method - offends when module_function is not inlined and has a comment - offends when private is not inlined and has a comment - accepts when #{access_modifier} is a hash literal value - accepts when #{access_modifier} is a hash literal value - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when methods are modified by group modifier - registers and autocorrects an offense - when methods are modified by group modifier - registers and autocorrects an offense - when methods are modified by group modifier - registers and autocorrects an offense - when methods are modified by group modifier - registers and autocorrects an offense - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when `group` is configured - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - offends when protected is inlined with a method - does not offend when protected is not inlined and has a comment - accepts when using only #{access_modifier} - accepts when #{access_modifier} is a hash literal value - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - accepts when #{access_modifier} is a hash literal value - does not registers an offense when using #{access_modifier} in a block - accepts when #{access_modifier} is a hash literal value - does not offend when protected is not inlined - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - does not registers an offense when using #{access_modifier} in a block - accepts when using only #{access_modifier} - does not registers an offense when using #{access_modifier} in a block - does not offend when public is not inlined - does not registers an offense when using #{access_modifier} in a block - accepts when #{access_modifier} is a hash literal value - does not offend when private is not inlined - registers an offense for correct + multiple opposite styles of #{access_modifier} usage - does not offend when private is not inlined and has a comment - accepts when using only #{access_modifier} - does not offend when module_function is not inlined - does not offend when public is not inlined and has a comment - accepts when using only #{access_modifier} - offends when module_function is inlined with a method - offends when public is inlined with a method - does not offend when module_function is not inlined and has a comment - offends when private is inlined with a method - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier where group modifier already exists - registers and autocorrects an offense - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier with disallowed symbol - registers and autocorrects an offense - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when non-existent method is modified by inline modifier with disallowed symbol - registers an offense but does not autocorrect it - when method is modified by inline modifier with disallowed symbol - registers and autocorrects an offense - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier with disallowed symbol - registers and autocorrects an offense - when method is modified by inline modifier where group modifier already exists - registers and autocorrects an offense - when method has comments - registers and autocorrects an offense - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier with disallowed symbol - registers and autocorrects an offense - when method is modified by inline modifier - registers and autocorrects an offense - allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier - registers and autocorrects an offense - when non-existent method is modified by inline modifier with disallowed symbol - registers an offense but does not autocorrect it - when method has comments - registers and autocorrects an offense - when method has comments - registers and autocorrects an offense - when method is modified by inline modifier where group modifier already exists - registers and autocorrects an offense - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol - when method is modified by inline modifier - registers and autocorrects an offense - when non-existent method is modified by inline modifier with disallowed symbol - registers an offense but does not autocorrect it - when non-existent method is modified by inline modifier with disallowed symbol - registers an offense but does not autocorrect it - when method is modified by inline modifier where group modifier already exists - registers and autocorrects an offense - when method is modified by inline modifier - registers and autocorrects an offense - when method has comments - registers and autocorrects an offense - do not allow access modifiers on symbols - accepts when argument to #{access_modifier} is a symbol +RuboCop::Formatter::GitHubActionsFormatter + #finished + when file is relative to the current directory + reports offenses as error with the relative path + when no offenses are detected + does not print anything + when message contains % + escapes message + when offenses are detected + reports offenses as errors + when fail level is defined + reports offenses below fail level as warnings + reports offenses above or at fail level as errors RuboCop::Formatter::ClangStyleFormatter #report_file displays text containing the offending source line - when the offense is automatically corrected - prints [Corrected] along with message when the offense is not corrected prints message as-is + when the source line is blank + does not display offending source line when the source contains multibyte characters displays text containing the offending source line + when the offense is automatically corrected + prints [Corrected] along with message when the offense is correctable prints message as-is - when the source line is blank - does not display offending source line when the offending source spans multiple lines displays the first line with ellipses -RuboCop::Formatter::SimpleTextFormatter - #report_file - behaves like report for severity - when the offense is marked as todo - prints [Todo] along with message - when the offense is automatically corrected - prints [Corrected] along with message - when the offense is correctable - prints message as-is - the file is under the current working directory - prints as relative path - the file is outside of the current working directory - prints as absolute path - when the offense is not corrected - prints message as-is - behaves like report for severity - when the offense is not corrected - prints message as-is - the file is outside of the current working directory - prints as absolute path - when the offense is correctable - prints message as-is - the file is under the current working directory - prints as relative path - when the offense is automatically corrected - prints [Corrected] along with message - when the offense is marked as todo - prints [Todo] along with message - behaves like report for severity - when the offense is marked as todo - prints [Todo] along with message - when the offense is automatically corrected - prints [Corrected] along with message - the file is outside of the current working directory - prints as absolute path - the file is under the current working directory - prints as relative path - when the offense is correctable - prints message as-is - when the offense is not corrected - prints message as-is - behaves like report for severity - the file is outside of the current working directory - prints as absolute path - when the offense is marked as todo - prints [Todo] along with message - when the offense is automatically corrected - prints [Corrected] along with message - the file is under the current working directory - prints as relative path - when the offense is correctable - prints message as-is - when the offense is not corrected - prints message as-is - behaves like report for severity - when the offense is not corrected - prints message as-is - when the offense is automatically corrected - prints [Corrected] along with message - the file is under the current working directory - prints as relative path - the file is outside of the current working directory - prints as absolute path - when the offense is marked as todo - prints [Todo] along with message - when the offense is correctable - prints message as-is - behaves like report for severity - when the offense is correctable - prints message as-is - the file is under the current working directory - prints as relative path - when the offense is automatically corrected - prints [Corrected] along with message - when the offense is not corrected - prints message as-is - the file is outside of the current working directory - prints as absolute path - when the offense is marked as todo - prints [Todo] along with message - #report_summary - when 2 offenses detected - handles pluralization correctly - when a offense detected and a offense autocorrectable - handles pluralization correctly - when 2 offenses are corrected - handles pluralization correctly - when a offense detected - handles pluralization correctly - when no files inspected - handles pluralization correctly - when a file inspected and no offenses detected - handles pluralization correctly - when 2 offenses are corrected and 2 offenses autocorrectable - handles pluralization correctly - when an offense is corrected - prints about correction - when 2 offenses detected and 2 offenses autocorrectable - handles pluralization correctly - -RuboCop::Cop::Layout::IndentationWidth - with Width set to 2 - with module - leaves body unchanged if the first body line is on the same line with module keyword - when consistency style is normal - accepts an empty module body - registers an offense for bad indentation of a module body - when consistency style is indented_internal_methods - accepts normal non-indented internal methods of module functions - registers an offense for bad indentation of a module body - with def/defs - when end is aligned with start of line - accepts an empty defs body - registers an offense for bad indentation of a def body - with an assignment - registers an offense for bad indentation of a defs body - accepts an empty def body - when multiple modifiers and def are on the same line - registers an offense for bad indentation of a defs body - registers an offense for bad indentation of a def body - accepts a correctly aligned body - when multiple modifiers are used in a block anda method call is made at end of the block - accepts a correctly aligned body - registers an offense for bad indentation of a def - registers an offense for bad indentation of a def body - when modifier and def are on the same line - registers an offense for bad indentation of a def body - accepts a correctly aligned body - registers an offense for bad indentation of a defs body - when end is aligned with def - accepts an empty defs body - with an assignment - registers an offense for bad indentation of a def body - accepts an empty def body - registers an offense for bad indentation of a defs body - when modifier and def are on the same line - accepts a correctly aligned body - registers an offense for bad indentation of a def body - registers an offense for bad indentation of a defs body - with unless - accepts an empty unless - registers an offense for bad indentation of an unless body - with block - accepts badly indented code if block end is not on separate line - accepts an empty block body - accepts a correctly indented block body - registers an offense for bad indentation of `do` ... `ensure` ... `end` block - registers an offense for bad indentation of a do/end body - does not register an offense for good indentation of `do` ... `ensure` ... `end` block - registers an offense for bad indentation of a {} body - Ruby 2.7 - registers an offense for bad indentation of a {} body - registers an offense for bad indentation of a do-end body - when consistency style is indented_internal_methods - registers an offense for bad indentation in a do/end body - when using safe navigation operator - registers an offense for bad indentation of a {} body - registers an offense for an if with setter - with if statement - accepts a one line if statement - accepts `rescue`/`ensure` after an empty def - does not correct in scopes that contain block comments - leaves block unchanged if block end is not on its own line - registers an offense for bad indentation of an if body - accepts `ensure` after an empty def - registers and corrects on offense for bad indentation - registers an offense for bad indentation of an elsif body - accepts an empty if - accepts `ensure` after an empty body - does not raise any error with empty braces - accepts indentation after if on new line after assignment - registers offense for bad indentation of ternary inside else - does not indent heredoc strings - accepts if/elsif/else/end laid out as a table - accepts if/then/else/end laid out as another table - registers offense for bad indentation of modifier if in else - accepts `rescue` after an empty def - registers an offense for bad indentation of an else body when if body contains no code - accepts `rescue` after an empty body - handles lines with only whitespace - accepts a correctly aligned if/elsif/else/end - accepts an if/else branches with rescue clauses - accepts a correctly aligned if/elsif/else/end as a method argument - registers an offense for bad indentation of an else body - leaves rescue ; end unchanged - accepts `rescue`/`ensure` after an empty body - registers an offense for bad indentation of an else body when if and elsif body contains no code - indents parenthesized expressions - with assignment - when alignment style is start_of_line - and end is aligned randomly - registers an offense for an until - registers an offense for an if - registers an offense for a while - and end is aligned with keyword - registers an offense for a while - accepts an if/else in assignment on next line - registers an offense for an until - registers an offense for an if with setter - registers an offense for an if - registers an offense for an if with element assignment - and end is aligned with variable - accepts an if/else with chaining after the end - accepts an if/else with chaining with a block after the end - accepts an if with end aligned with variable - accepts an if with end aligned with element assignment - accepts an if/else - accepts an if with end aligned with setter - when alignment style is variable - and end is aligned randomly - registers an offense for a while - registers an offense for an if - registers an offense for an until - and end is aligned with variable - accepts an if with end aligned with element assignment - accepts an if/else with chaining with a block after the end - accepts an if with end aligned with variable - accepts an if/else - accepts an if/else with chaining after the end - accepts an if with end aligned with setter - and end is aligned with keyword - registers an offense for an if with setter - registers an offense for an if with element assignment - registers an offense for a while - accepts an if/else in assignment on next line - registers an offense for an until - registers an offense for an if - when alignment style is keyword - and end is aligned with variable - registers an offense for an if - registers an offense for a while - registers and corrects bad indentation - and end is aligned with keyword - accepts an if/else in assignment on next line - accepts a while in assignment - accepts an until in assignment - accepts an if/else in assignment - accepts an if in assignment - with class - accepts an empty class body - leaves body unchanged if the first body line is on the same line with class keyword - registers an offense for bad indentation of a class body - leaves body unchanged if the first body line is on the same line with an opening of singleton class - when consistency style is indented_internal_methods - registers an offense for normal non-indented internal methods indentation when defined in a singleton class - registers an offense for normal non-indented internal methods indentation - with access modifier - registers an offense for bad indentation of sections - registers an offense and corrects for bad modifier indentation before good method definition - when consistency style is normal - accepts indented public, protected, and private - registers offenses for indented_internal_methods indentation - when consistency style is outdent - accepts access modifier is outdent - with case - registers an offense for bad indentation in a case/when body - registers an offense for bad indentation in a case/else body - accepts case/when/else laid out as a table - accepts aligned values in when clause - accepts indented when/else plus indented body - accepts case/when/else with then beginning a line - accepts correctly indented case/when/else - with begin/rescue/else/ensure/end - registers an offense for bad indentation of bodies - with case match - accepts case/in/else laid out as a table - accepts indented in/else plus indented body - accepts case/in/else with then beginning a line - registers an offense for bad indentation in a case/else body - registers an offense for bad indentation in a case/in body - accepts aligned value in `in` clause and `else` is empty - accepts correctly indented case/in/else - accepts aligned values in `in` clause - with def/rescue/end - registers an offense for bad indent of defs bodies with a modifier - registers an offense for bad indentation of bodies - with while/until - registers an offense for bad indentation of an until body - accepts an empty while - registers an offense for bad indentation of begin/end/while - registers an offense for bad indentation of a while body - with for - registers an offense for bad indentation of a for body - accepts an empty for - with Width set to 4 - registers and corrects offense for bad indentation - with if statement - registers an offense for bad indentation of an if body - with ignored patterns set - accepts unindented lines for those keywords - for a file with byte order mark - accepts correctly indented method definition +RuboCop::Cop::Style::MultilineIfThen + does not get confused by a commented-out then + registers an offense for then in multiline if + registers an offense for then in multiline unless + accepts table style if/then/elsif/ends + does not raise an error for an implicit match if + does not get confused by a nested postfix unless + does not get confused by empty elsif branch + does not get confused by a then in a when + registers an offense for then in multiline elsif + does not raise an error for an implicit match unless + does not get confused by a postfix unless -RuboCop::Cop::Layout::FirstHashElementLineBreak - ignores implicit hashes in method calls without parens - ignores implicit hashes in method calls with parens - registers an offense and corrects elements listed on the first line - ignores implicit hashes in method calls that are improperly formatted - ignores elements listed on a single line - registers an offense and corrects single element multi-line hash - registers an offense and corrects hash nested in a method call +RuboCop::Cop::Style::HashSyntax + configured to enforce explicit hash value syntax style + Ruby <= 3.0 + does not register an offense when hash key and hash value are the same + Ruby >= 3.1 + does not register an offense when hash key and hash value are the same + registers and corrects an offense when hash values are omitted + registers and corrects an offense when hash key and hash value are partially the same + does not register an offense when hash key and hash value are not the same + configured to enforce ruby 1.9 style with no mixed keys + UseHashRocketsWithSymbolValues disabled + registers an offense when keys start with a digit + registers an offense when keys have special symbols in them + accepts new syntax in method calls + accepts hash rockets when keys have different types + accepts new syntax in a hash literal + registers offense for hash rocket syntax when new is possible + registers an offense when keys have whitespaces in them + registers an offense for mixed syntax when new is possible + registers an offense for hash rockets in method calls + accepts an empty hash + registers an offense when keys have different types and styles + accepts new syntax when keys are interpolated string + ruby < 2.2 + registers an offense when keys start with a digit and mix styles + accepts hash rockets when keys start with a digit + registers an offense when keys have special symbols and mix styles + accepts hash rockets when keys have whitespaces in them + registers an offense when keys have whitespaces and mix styles + accepts hash rockets when keys have special symbols in them + UseHashRocketsWithSymbolValues enabled + registers an offense when keys have whitespaces in them + accepts hash rockets when keys have different types + registers an offense for hash rockets in method calls + registers an offense for mixed syntax when new is possible + registers an offense when keys have different types and styles + autocorrects to hash rockets when all elements have symbol value + accepts new syntax in method calls + accepts new syntax when keys are interpolated string + registers an offense when any element has a symbol value in method calls + accepts new syntax in a hash literal + accepts an empty hash + registers an offense when keys have special symbols in them + registers an offense when any element uses a symbol for the value + registers offense for hash rocket syntax when new is possible + registers an offense when keys start with a digit + ruby < 2.2 + registers an offense when keys have special symbols and mix styles + accepts hash rockets when keys start with a digit + registers an offense when keys start with a digit and mix styles + accepts hash rockets when keys have special symbols in them + registers an offense when keys have whitespaces and mix styles + accepts hash rockets when keys have whitespaces in them + configured to enforce hash rockets style + registers an offense for mixed syntax + registers an offense for 1.9 style in method calls + registers offense for Ruby 1.9 style + accepts hash rockets in method calls + accepts an empty hash + accepts hash rockets in a hash literal + UseHashRocketsWithSymbolValues has no impact + does not register an offense when there is a symbol value + configured to disallow mixing of implicit and explicit hash literal value + Ruby >= 3.1 + does not register an offense when all hash values are present, but only some values can be omitted + registers an offense when some hash values are omitted but they can all be omitted + registers an offense when all hash values are present, but can all be omitted + does not register an offense when all hash values are present, but no values can be omitted + does not register an offense when all hash values are omitted + registers an offense when some hash values are omitted but they cannot all be omitted + Ruby <= 3.0 + does not register an offense when all hash key and hash values are the same + configured to accept both shorthand and explicit use of hash literal value + Ruby <= 3.0 + does not register an offense when hash key and hash value are the same + Ruby >= 3.1 + does not register an offense when hash key and hash value are the same + does not register an offense when hash key and hash value are not the same + does not register an offense when hash values are omitted + does not register an offense when hash key and hash value are partially the same + configured to enforce shorthand syntax style + Ruby >= 3.1 + does not register an offense when without parentheses call expr follows after nested method call + registers an offense when one line `if` condition follows (with parentheses) + registers and corrects an offense when `Hash[foo: foo]` + does not register an offense when one line `if` condition follows (without parentheses) + does not register an offense when without parentheses call expr follows + does not register an offense when hash key and hash value are the same but the value ends `!` + registers an offense when one line `until` condition follows (with parentheses) + registers and corrects an offense when `Hash[foo: foo]` and an expression follows + does not register an offense when `return` with one line `if` condition follows (without parentheses) + registers and corrects an offense when hash key and hash value are the same and it in the method body + registers an offense when hash key and hash value are not the same and method with `[]` is called + does not register an offense when symbol hash key and hash value (lvar) are not the same + does not register an offense when lvar hash key and hash value are the same + does not register an offense when hash key and hash value are partially the same + does not register an offense when method call hash key and hash value are the same + does not register an offense when call expr without arguments and with a block follows + registers and corrects an offense when hash key and hash value are partially the same + does not register an offense when hash values are omitted + registers and corrects an offense when hash key and hash value (lvar) are the same + does not register an offense when with parentheses call expr follows + does not register an offense when hash key and hash value are not the same + does not register an offense when with parentheses call expr follows assignment expr + does not register an offense when hash key and hash value are the same but the value ends `?` + registers and corrects an offense when hash key and hash value are the same and it in the method bodyand an expression follows + does not register an offense when one line `until` condition follows (without parentheses) + registers and corrects an offense when hash key and hash value are the same + does not register an offense when call expr with argument and a block follows + does not register an offense when symbol hash key and string hash value are the same + does not register an offense when hash pattern matching + when hash roket syntax + does not register an offense + Ruby <= 3.0 + does not register an offense when hash key and hash value are the same + configured to enforce ruby19 style + with SpaceAroundOperators enabled + registers an offense for hash rockets in method calls + accepts an empty hash + registers an offense when symbol keys have strings in them + accepts hash rockets when keys have different types + accepts hash rockets when symbol keys end with = + accepts new syntax in method calls + accepts new syntax in a hash literal + autocorrects even if it interferes with SpaceAroundOperators + registers offense for hash rocket syntax when new is possible + preserves quotes during autocorrection + autocorrects a missing space when hash is used as argument + registers an offense for mixed syntax when new is possible + registers offense when keys start with an uppercase letter + accepts hash rockets when symbol characters are not supported + when using a return value uses `return` + registers an offense and corrects when enclosed in parentheses + registers an offense and corrects when not enclosed in parentheses + if PreferHashRocketsForNonAlnumEndingSymbols is true + accepts hash rockets when symbols end with ! + accepts hash rockets when symbols end with ? + ruby < 2.2 + accepts hash rockets when symbol keys have string in them + if PreferHashRocketsForNonAlnumEndingSymbols is false + registers an offense for hash rockets when symbols end with ? + registers an offense for hash rockets when symbols end with ! + configured to use hash rockets when symbol values are found + registers an offense for hashes with elements on multiple lines + accepts ruby19 syntax when no elements have symbol values in method calls + accepts ruby19 syntax when no elements have symbol values + registers an offense when any element uses a symbol for the value + accepts both hash rockets and ruby19 syntax in the same code + autocorrects to hash rockets when all elements have symbol value + registers an offense when using hash rockets and no elements have a symbol value + accepts an empty hash + registers an offense when any element has a symbol value in method calls + accepts hash in ruby19 style with no symbol values + with SpaceAroundOperators disabled + autocorrects even if there is no space around => + configured to enforce no mixed keys + accepts new hash style + accepts hash rockets when keys have different types + accepts hash rockets when keys have special symbols in them + accepts the hash rocket syntax when new is possible + registers an offense when keys start with a digit and mix styles + accepts new syntax in a hash literal + autocorrects mixed key hashes + registers an offense when keys have special symbols and mix styles + registers an offense for mixed syntax when new is possible + registers an offense when keys have whitespaces and mix styles + accepts new syntax in method calls + accepts old hash rockets style + registers an offense when keys have different types and styles + accepts an empty hash + accepts hash rockets when keys start with a digit + accepts hash rockets when keys have whitespaces in them + accepts hash rockets in method calls -RuboCop::Cop::Lint::OrderedMagicComments - does not register an offense when using `encoding: Encoding::SJIS` Hash notation after`frozen_string_literal` magic comment - does not register an offense when using `encoding` magic comment only - registers an offense and corrects when `coding` magic comment does not precede all other magic comments - does not register an offense when using `encoding` magic comment is next of shebang - registers an offense and corrects when `-*- encoding : ascii-8bit -*-` magic comment does not precede all other magic comments - does not register an offense when using `frozen_string_literal` magic comment only - registers an offense and corrects when using `frozen_string_literal` magic comment is next of shebang - registers an offense and corrects when an `encoding` magic comment does not precede all other magic comments - does not register an offense when using `encoding` magic comment is first line +RuboCop::Cop::Lint::ConstantOverwrittenInRescue + does not register an offense when not overriding an exception with an exception result + does not register an offense when using `=>` but correctly assigning to variables + registers an offense when overriding an exception with an exception result -RuboCop::Cop::Lint::NumberConversion - IgnoredClasses - when using Time - when using DateTime - when using Time/DateTime with multiple method calls - AllowedMethods - does not register an offense for an allowed method - registers an offense for other methods - does not register an offense - when `#to_i` called without a receiver - when using Complex() - when `:to_f` is one of multiple method arguments - when using Integer() with integer - when using Float() - AllowedPatterns - registers an offense for other methods - does not register an offense for an allowed method - registers an offense - when using `#to_f` for number literals - when `#to_i` called on a variable on a array - when using `#to_c` - when using `#to_c` for number literals - when using `#to_f` - when using `#to_r` - when using `#to_i` for number literals - when using `#to_r` for number literals - when `#to_i` called on a variable on a hash - when using `#to_i` - when `#to_i` called on a variable - when `#to_i` called on a hash value - to_method in symbol form - does not register an offense when using `Float` constructor - registers offense with send - does not register an offense when using `Complex` constructor - does not register an offense when using `Integer` constructor - registers offense and autocorrects without parentheses - registers offense with try - registers offense and autocorrects - registers an offense when using nested number conversion methods +RuboCop::Cop::Lint::UnusedMethodArgument + inspection + when an underscore-prefixed method argument is unused + accepts + when a variable is unused + does not care + when an optional keyword argument is unused + registers an offense but does not suggest underscore-prefix + and AllowUnusedKeywordArguments set + does not care + when a block argument is unused + does not care + when a singleton method argument is unused + registers an offense + when a method argument is used + accepts + in a method calling `binding` with arguments + when a method argument is unused + registers an offense + when a method takes multiple arguments + and an argument is unused + registers an offense and adds underscore-prefix + and arguments are swap-assigned + accepts + and one argument is assigned to another, whilst other's value is not used + registers an offense + and there is some whitespace around the unused argument + registers an offense and preserves whitespace + and all the arguments are unused + registers offenses and suggests the use of `*` and autocorrects to add underscore-prefix to all arguments + in a method calling `super` with arguments + when a method argument is unused + registers an offense + when a splat argument is unused + registers an offense and preserves the splat + when a trailing block argument is unused + registers an offense and removes the unused block arg + in a method calling `binding` without arguments + accepts all arguments + inside another method definition + registers offenses + when a required keyword argument is unused + when a required keyword argument is unused + registers an offense but does not suggest underscore-prefix + in a method calling `super` without arguments + when a method argument is not used explicitly + accepts since the arguments are guaranteed to be the same as superclass' ones and the user has no control on them + when an argument with a default value is unused + registers an offense and preserves the default value + when IgnoreNotImplementedMethods config parameter is set + accepts a method with a single unused parameter & fails with message + accepts an empty method with multiple unused parameters + registers an offense for a non-empty method with a single unused parameter + accepts a method with a single unused parameter & raises NotImplementedError + registers an offense for a non-empty method with multiple unused parameters + accepts a method with a single unused parameter & raises NotImplementedError, message + accepts a method with a single unused parameter & fails without message + accepts a method with a single unused parameter & raises ::NotImplementedError + accepts an empty singleton method with a single unused parameter &raise NotImplementedError + when IgnoreEmptyMethods config parameter is set + accepts an empty singleton method with a single unused parameter + registers an offense for a non-empty method with multiple unused parameters + accepts an empty method with a single unused parameter + registers an offense for a non-empty method with a single unused parameter + accepts an empty method with multiple unused parameters -RuboCop::Formatter::TapFormatter - #finished - when no offenses are detected - does not report offenses - when any offenses are detected - reports all detected offenses for all failed files - #report_file - when the source contains multibyte characters - displays text containing the offending source line - #file_finished - when any offenses are detected - prints "not ok" - when no offenses are detected - prints "ok" - -RuboCop::Cop::Lint::IdentityComparison - registers an offense and corrects when using `==` for comparison between `object_id`s - does not register an offense when lhs is `object_id` without receiver - does not register an offense when using `==` - does not register an offense when rhs is `object_id` without receiver - does not register an offense when using `==` for comparison between `object_id` and other - does not register an offense when a receiver that is not `object_id` uses `==` - -RuboCop::Cop::Layout::MultilineOperationIndentation - when EnforcedStyle is indented - accepts double indentation of if condition - registers an offense and corrects aligned code on LHS of equality operator - does not check method calls - accepts indentation of next if condition - accepts double indentation of until condition - accepts double indentation of unless condition - accepts indented operands in if condition - registers an offense and corrects one space indentation of second line - registers an offense for a 2 space indentation of if condition - accepts indentation of return if condition - accepts normal indentation inside grouped expression - accepts indented operands in an array - registers an offense for a 2 space indentation of while condition - registers an offense and corrects wrong indentation of for expression - accepts indented operands in while body - registers an offense and corrects extra indentation of third line - accepts any indentation of method parameters - registers an offense for a 2 space indentation of until condition - registers an offense and corrects an unindented multiline operation that is the left operand in another operation - accepts indented operands in if body - accepts special indentation of for expression - accepts any indentation of parameters to #[] - accepts normal indentation of method parameters - accepts double indentation of while condition - accepts the indentation of a broken string - registers an offense and corrects emacs ruby-mode 1.1 indentation of an expression in an array - accepts indentation of return unless condition - registers an offense and corrects aligned operands in if conditions - accepts two spaces indentation in assignment of local variable - registers an offense and corrects correct + unrecognized style - accepts indented operands in until body - accepts indented operands in unless body - registers an offense and corrects no indentation of second line - accepts indented operands in ordinary statement - accepts two spaces indentation in assignment of array element - registers an offense and corrects three space indentation of second line - accepts unary operations - accepts indentation of next unless condition - accepts indented operands in for body - registers an offense for a 2 space indentation of unless condition - accepts an expression where the first operand spans multiple lines - accepts alignment inside a grouped expression - accepts indented operands inside and outside a block - accepts indentation of assignment - accepts no extra indentation of third line - accepts two spaces indentation of second line - registers an offense and corrects aligned operators in assignment - when indentation width is overridden for this cop - accepts indentation of unless condition which is offset by a single normal indentation step - registers an offense and corrects - accepts indented operands in while body - accepts indentation of if condition which is offset by a single normal indentation step - accepts indented operands in if body - accepts indented operands in if condition - registers an offense for a 4 space indentation of if condition - accepts indented operands in unless body - accepts indentation of until condition which is offset by a single normal indentation step - registers an offense for a 4 space indentation of while condition - registers an offense for a 4 space indentation of unless condition - registers an offense for a 4 space indentation of until condition - accepts indentation of while condition which is offset by a single normal indentation step - accepts indented operands in until body - when EnforcedStyle is aligned - accepts an expression where the first operand spans multiple lines - registers an offense for misaligned operands in if condition - accepts indented code on LHS of equality operator - registers an offense and corrects an unindented multiline operation that is the left operand in another operation - accepts indented operands inside block + assignment - registers an offense and corrects indented operands in if condition - accepts aligned operands in if condition - accepts indented operands in an array - registers an offense for misaligned operands in until condition - registers an offense and corrects misaligned operands in unless condition - registers an offense and corrects extra indentation of third line - registers an offense and corrects misaligned string operand when the first operand has backslash continuation - accepts no extra indentation of third line - registers an offense and corrects one space indentation of second line - accepts two spaces indentation in assignment of array element - registers an offense for misaligned operands in unless condition - registers an offense and corrects misaligned string operand when plus is used - registers an offense and corrects emacs ruby-mode 1.1 indentation of an expression in an array - registers an offense and corrects no indentation of second line - accepts alignment inside a grouped expression - registers an offense and corrects indented second part of string - accepts unary operations - registers an offense and corrects indented operand in second argument - accepts indented operands in ordinary statement - registers an offense for misaligned operands in while condition - registers an offense and corrects unaligned operands in op-assignment - accepts indented operands inside and outside a block - accepts aligned or:ed operands in assignment - accepts aligned operands in assignment - accepts any indentation of parameters to #[] - registers an offense and corrects three space indentation of second line - accepts indented operands with ternary operators - does not check method calls - accepts indented operands in for body - accepts two spaces indentation in assignment of local variable - accepts two spaces indentation of second line - -RuboCop::Cop::Security::MarshalLoad - does not register an offense for Marshal.dump - allows using dangerous Marshal methods for deep cloning - does not register an offense Marshal methods under another namespace - registers an offense for using Marshal.restore - registers an offense for using Marshal.load - -RuboCop::Cop::Style::MultilineBlockChain - accepts a multi-line block chained with calls on one line - accepts a chain of blocks spanning one line - accepts a chain of calls followed by a multi-line block - with multi-line block chaining - accepts a chain where the first block is single-line - registers an offense for a simple case - registers two offenses for a chain of three blocks - registers an offense for a slightly more complicated case - registers an offense for a chain where the second block is single-line - Ruby 2.7 - registers an offense for a slightly more complicated case - -RuboCop::Cop::InternalAffairs::RedundantContextConfigParameter - does not register an offense when using `:config` in other than `context` - does not register an offense when using `:ruby30` only - registers an offense when using `:config` parameter - registers an offense when using `:config` parameter with other parameters - does not register an offense when not using `:config` - -RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces - accepts hash literals with no braces - registers an offense for correct + opposite - accepts hashes with spaces by default - can handle interpolation in a braceless hash literal - registers an offense for hashes with no spaces if so configured - with space inside empty braces allowed - registers an offense for empty braces with no space inside - accepts empty braces with space inside - when using method argument that both key and value are hash literals - registers hashes with no spaces - on { key: "{" } - does not register an offense - on Hash[{ x: 1 } => [1]] - does not register an offense - with newline inside empty braces not allowed - registers an offense - offending hash following empty hash - registers an offense on both sides - when EnforcedStyle is compact - registers an offense for opposite + correct - registers offenses for hashes with no spaces - accepts multiline hash with comment - doesn't register an offense for non-nested hashes with spaces - accepts multiline hash - registers an offense for nested hashes with spaces - when EnforcedStyle is no_space - registers an offense for opposite + correct - accepts hashes with no spaces - accepts multiline hash with comment - registers an offense for hashes with spaces - accepts multiline hash - when using method argument that both key and value are hash literals - accepts hashes with no spaces - with space inside empty braces not allowed - accepts empty braces with no space inside - registers an offense for empty braces with space inside - -RuboCop::Cop::Style::Semicolon - registers an offense for range (`1...42`) with semicolon - accept semicolons inside strings - accepts semicolon before end if so configured - registers an offense for several expressions - registers an offense for one line method with two statements - accepts one line empty module definitions - registers an offense for range (`1..42`) with semicolon - registers an offense for a single expression - accepts one line method definitions - registers an offense for a semicolon at the beginning of a line - accepts one line empty class definitions - registers an offense for semicolon at the end no matter what - accepts one line empty method definitions - accepts semicolon after params if so configured - with a multi-expression line without a semicolon - does not register an offense - when AllowAsExpressionSeparator is true - accepts one line method with two statements - accepts several expressions - Ruby >= 2.6 - registers an offense for endless range with semicolon in the method definition - does not register an offense for endless range without semicolon - registers an offense for endless range with semicolon (irange and erange) - registers an offense for endless range with semicolon (irange only) - -RuboCop::Cop::Style::ExplicitBlockArgument - does not add extra parens when correcting - does not register an offense when code is called outside of a method - correctly corrects when the method call has a trailing comma in its argument list - registers an offense and corrects when block just yields its arguments - registers an offense and corrects when multiple arguments are yielded - does not register an offense when arguments are yielded in a different order - does not register an offense when `yield` is the sole block body - correctly corrects when method already has an explicit block argument - registers an offense and corrects when `yield` inside block has no arguments - registers an offense and corrects when method contains multiple `yield`s - correctly corrects when using safe navigation method call - adds to the existing arguments when correcting - does not add extra parens to `super` when correcting - does not register an offense when there is more than one block argument and not all are yielded - does not register an offense when `yield` is not inside block - does not register an offense when `yield` arguments is not a prefix of block arguments - registers an offense and corrects when `yield` is inside block of `super` - -RuboCop::Cop::Layout::ArrayAlignment - when aligned with fixed indentation - does not indent heredoc strings when autocorrecting - accepts aligned array keys - autocorrects array within array with too much indentation - autocorrects array within array with too little indentation - accepts aligned array with fullwidth characters - autocorrects misaligned array with the first element on a new row - registers an offense and corrects misaligned array elements - accepts single line array - accepts several elements per line - accepts the first element being on a new row - does not register an offense or try to correct parallel assignment - when aligned with first parameter - does not register an offense or try to correct parallel assignment - autocorrects array within array with too much indentation - accepts single line array - autocorrects array within array with too little indentation - autocorrects misaligned array with the first element on a new row - accepts aligned array with fullwidth characters - accepts aligned array keys - registers an offense and corrects misaligned array elements - accepts the first element being on a new row - does not indent heredoc strings when autocorrecting - accepts several elements per line +RuboCop::PathUtil + #match_path? + matches regexps + does not match invalid UTF-8 paths + matches glob expressions + matches strings to the full path + matches dir/** for hidden file + does not match file in a subdirectory + does not match dir/** for file in hidden dir + #absolute? + returns a falsey value for a path beginning with a directory name + returns a truthy value for a path beginning with slash + #relative_path + builds paths relative to PWD by default as a stop-gap + supports custom base paths -RuboCop::Cop::EnforceSuperclass - registers an offense for models that subclass ::ActiveRecord::Base - registers an offense for single-line definitions - registers an offense for model defined using top-level - registers an offense for Class.new definition - registers an offense for top-level constant ::Class.new definition - registers an offense for models that subclass ActiveRecord::Base - when MyModel subclasses ApplicationRecord - behaves like no offense - registers no offenses for `MyModel = Class.new(ApplicationRecord) do -end -MyModel = Class.new(ApplicationRecord) -` - behaves like no offense - registers no offenses for `class MyModel < ApplicationRecord; end` - behaves like no offense - registers no offenses for `MyModel = ::Class.new(::ApplicationRecord) do -end -MyModel = ::Class.new(::ApplicationRecord) -` - behaves like no offense - registers no offenses for `class MyModel < ::ApplicationRecord; end` - when ApplicationRecord subclasses ActiveRecord::Base - behaves like no offense - registers no offenses for `::ApplicationRecord = ::Class.new(::ActiveRecord::Base) do; end -` - behaves like no offense - registers no offenses for `::ApplicationRecord = Class.new(ActiveRecord::Base) do; end -` - behaves like no offense - registers no offenses for `::ApplicationRecord = ::Class.new(::ActiveRecord::Base) -` - behaves like no offense - registers no offenses for `class ApplicationRecord < ActiveRecord::Base; end` - behaves like no offense - registers no offenses for `ApplicationRecord = Class.new(::ActiveRecord::Base) do; end -` - behaves like no offense - registers no offenses for `class ::ApplicationRecord < ActiveRecord::Base; end` - behaves like no offense - registers no offenses for `ApplicationRecord = Class.new(ActiveRecord::Base) do; end -` - behaves like no offense - registers no offenses for `ApplicationRecord = Class.new(ActiveRecord::Base) -` +RuboCop::Cop::Severity + has a few required attributes + overrides #to_s + is frozen + redefines == to compare severities + #level + fatal + is expected to eq 6 + warning + is expected to eq 4 + error + is expected to eq 5 + convention + is expected to eq 3 + info + is expected to eq 1 + refactor + is expected to eq 2 + #code + info + is expected to eq "I" + refactor + is expected to eq "R" + fatal + is expected to eq "F" + warning + is expected to eq "W" + convention + is expected to eq "C" + error + is expected to eq "E" + Comparable + warning + is expected to be < error + error + is expected to be < fatal + convention + is expected to be < warning + refactor + is expected to be < convention + info + is expected to be < refactor + constructs from code + F + is expected to eq # + I + is expected to eq # + E + is expected to eq # + W + is expected to eq # + C + is expected to eq # + R + is expected to eq # -RuboCop::Cop::Security::JSONLoad - allows JSON.dump - registers an offense and corrects JSON.load - registers an offense and corrects JSON.restore - allows JSON.parse - does not register an offense for JSON under another namespace +RuboCop::Cop::Layout::EmptyLineAfterMagicComment + accepts magic comment with shareable_constant_value + registers offense when frozen_string_literal used with shareable_constant_value without empty line + accepts code that separates the comment from the code with a newline + accepts magic comment followed by encoding + registers an offense for code that immediately follows comment + accepts a source file with only a magic comment + registers an offense when code that immediately follows typed comment + registers an offense for documentation immediately following comment + accepts magic comment with typed + registers an offense when multiple magic comments without empty line + accepts an empty source file -RuboCop::YAMLDuplicationChecker - when yaml has duplicated keys in the top level - calls block with keys - calls block - when yaml does not have any duplication - does not call block - when yaml has duplicated keys in the second level - calls block with keys - calls block +RuboCop::Cop::Naming::AccessorMethodName + registers an offense for method get_something with no args + accepts singleton method set_something with no args + registers an offense for singleton method get_something with no args + accepts method set_something with no args + accepts method set_something with optarg + accepts method set_something with restarg + accepts method set_something with kwrestarg + accepts singleton method set_something with two args + accepts method set_something with kwarg + accepts method set_something with blockarg + accepts method set_something with kwoptarg + accepts singleton method get_something with args + accepts method set_something with two args + registers an offense for singleton method set_something with one args + registers an offense for method set_something with one arg + accepts method get_something with args + >= Ruby 2.7 + accepts method set_something with arguments forwarding -RuboCop::Cop::Layout::SpaceAroundMethodCallOperator - does not register an offense when using `__ENCODING__` - does not register an offense when no method call operator - :: operator - does not register an offense when no space around any `.` operators - does not register an offense if no space with conditionals - registers an offense and corrects when space after last method call operator - does not register an offense when no space around method call - registers an offense and corrects when space around intermediate method call operator - registers an offense and corrects when space after method call - does not register an offense if no space before `::` operator with assignment - registers an offense and corrects when multiple spaces with assignment - registers an offense and corrects when space after first operator with assignment - registers an offense and corrects when spaces after method call - registers an offense and corrects when space around multiple method call operator - does not register an offense if no space before `::` operator with inheritance - when multi line method call - does not register an offense when no space after the `::` - registers an offense and corrects when space before method call - dot operator - does not register an offense when no space around method call - registers an offense and corrects when space before first method call operator - registers an offense and corrects when spaces after method call - registers an offense and corrects when space after first method call operator - registers an offense and corrects when spaces around method call - registers an offense and corrects when space before method call - registers an offense and corrects when space after last method call operator - registers an offense and corrects when space around multiple method call operator - registers an offense and corrects when space after method call - registers an offense and corrects when space around intermediate method call operator - does not register an offense when no space around any `.` operators - registers an offense and corrects when spaces before method call - registers an offense and corrects when spaces after `Proc#call` shorthand call - registers an offense and corrects when space before last method call operator - when there is a space between `.` operator and a comment - does not register an offense when there is not a space before `.` - registers an offense when there is a space before `.` - when multi line method call - does not register an offense when no space after the `.` - registers an offense and corrects when space before method call in suffix chaining - registers an offense and corrects when space before method call - safe navigation operator - registers an offense and corrects when space around multiple method call operator - registers an offense and corrects when space before last method call operator - registers an offense and corrects when space before method call - registers an offense and corrects when space after last method call operator - registers an offense and corrects when spaces around method call - registers an offense and corrects when space after first method call operator - registers an offense and corrects when space around intermediate method call operator - registers an offense and corrects when spaces after method call - does not register an offense when no space around method call - registers an offense and corrects when space before first method call operator - does not register an offense when no space around any `.` operators - registers an offense and corrects when space after method call - registers an offense and corrects when spaces before method call - when multi line method call - registers an offense and corrects when space before method call in suffix chaining - registers an offense and corrects when space before method call - does not register an offense when no space after the `&.` +RuboCop::Cop::Style::SafeNavigation + allows a method call as a parameter when the parameter is safe guarded with an object check + allows calls to methods not safeguarded by respond_to + allows an object check before a nil check on a short chain + allows method call that is used in a regex comparison safe guarded by an object check + allows an object check before a method chain that is used in a comparison + allows method call that is used in a negated regex comparison safe guarded by an object check + allows an object check before hash access + allows an object check before a negated method call with a safe navigation + allows an object check before a negated predicate + allows a method call safeguarded when using `unless nil?` + allows method calls that do not get called using . safe guarded by an object check + allows an object check before a long chain with a block + allows an object check before a method call that is used in a regex comparison + allows an object check before a nil check on a long chain + allows object checks in the condition of an elsif statement and a method call on that object in the body + allows an object check before a method chain longer than 2 methods + allows calls using safe navigation + allows an object check before a negated predicate method chain + allows method call that is used in a comparison safe guarded by an object check + allows chained method calls during arithmetic operations safe guarded by an object check + allows an object check before a method call that is used in a negated regex comparison + allows for empty if blocks with comments + allows calls on nil + allows a method chain that is used in a comparison safe guarded by an object check + allows method call that is used in a spaceship comparison safe guarded by an object check + allows an object check before a method call that is used in a comparison + allows an object check before a method call that is used with `empty?` + allows a method call safeguarded with a negative check for the object when using `if` + allows an object check before a blank check + allows chained method calls during assignment safe guardedby an object check + allows an object check before a method call that is used in a spaceship comparison + does not move comments that are inside an inner block + allows a method call safeguarded with a negative check for the object when using `unless` + behaves like all variable types + if expression + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call with params and a block inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + registers an offense for a single method call with a block inside of a non-nil check for the object + registers an offense for a single method call inside of a non-nil check for the object + allows a single method call inside of a check for the object with an else + registers an offense for a single method call with params inside of a non-nil check for the object + does not lose comments within if expression + registers an offense for a single method call with a block inside of an unless nil check for the object + registers an offense for a single method call with params inside of a check for the object + registers an offense for a single method call with params and a block inside of an unless negative check for the object + registers an offense for a single method call inside of an unless negative check for the object + registers an offense for a single method call with a block inside of an unless negative check for the object + registers an offense for a single method call inside of an unless nil check for the object + registers an offense for a single method call inside of a check for the object + registers an offense for a single method call with a block inside of a check for the object + only moves comments that fall within the expression + ternary expression + allows ternary expression + modifier if + registers an offense for a method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a nil check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call safeguarded with a negative check for the object + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a check for the object + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call with params safeguarded with a negative nil check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + object check before method call + allows a non object check followed by a method call + allows a non object check followed by a method call with params and a block + allows a non object check followed by a method call with a block + allows a nil object check followed by a method call with a block + allows a nil object check followed by a method call with params and a block + allows a non object check followed by a method call with params + allows a nil object check followed by a method call + allows a nil object check followed by a method call with params + ConvertCodeThatCanStartToReturnNil true + registers an offense for an object check followed by a method call with params and a block + corrects an object check followed by a method call and another check + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with a block + registers an offense for a non-nil object check followed by a method call + registers an offense for a check for the object followed by a method call in the condition for an if expression + registers an offense for a non-nil object check followed by a method call with params + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with params and a block + method chaining + registers an offense for an object check followed by chained method calls with blocks + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls with blocks + allows an object check followed by chained method calls + MaxChainLength: 1 + allows an object check followed by 2 chained method calls + registers an offense for an object check followed by 1 chained method calls + MaxChainLength: 3 + registers an offense for an object check followed by 3 chained method calls + allows an object check followed by 4 chained method calls + ConvertCodeThatCanStartToReturnNil false + registers an offense for an object check followed by a method calls that nil responds to + registers an offense for an object check followed by a method call with a block + allows a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with params + registers an offense for an object check followed by a method call + allows a non-nil object check followed by a method call with params + allows a non-nil object check followed by a method call + registers an offense for an object check followed by a method call with params and a block + allows a non-nil object check followed by a method call with params and a block + registers an offense for a check for the object followed by a method call in the condition for an if expression + method chaining + corrects an object check followed by a chained method call with a symbol proc + corrects an object check followed by a chained method call + corrects an object check followed by a chained method call with a block + corrects an object check followed by a chained method call with params + when Ruby <= 2.2 + does not register an offense when a method call that nil responds to safe guarded by an object check + respond_to? + allows method calls safeguarded by a respond_to check on adifferent variable but the same method + allows method calls safeguarded by a respond_to check to a different method + allows enumerable accessor method calls safeguarded by a respond_to check + allows method calls safeguarded by a respond_to check + allows method calls safeguarded by a respond_to check on adifferent variable and method + behaves like all variable types + if expression + registers an offense for a single method call inside of a check for the object + registers an offense for a single method call with a block inside of a check for the object + registers an offense for a single method call inside of a non-nil check for the object + allows a single method call inside of a check for the object with an else + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of a check for the object + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + only moves comments that fall within the expression + registers an offense for a single method call with a block inside of an unless negative check for the object + registers an offense for a single method call with a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of a non-nil check for the object + registers an offense for a single method call with params and a block inside of an unless nil check for the object + does not lose comments within if expression + registers an offense for a single method call with params and a block inside of an unless negative check for the object + registers an offense for a single method call with a block inside of an unless nil check for the object + registers an offense for a single method call inside of an unless negative check for the object + ternary expression + allows ternary expression + modifier if + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call safeguarded with a negative check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense for a method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a negative nil check for the object + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a method call with a block safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense for a method call with params safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + object check before method call + allows a non object check followed by a method call with a block + allows a nil object check followed by a method call with params and a block + allows a nil object check followed by a method call with a block + allows a nil object check followed by a method call + allows a nil object check followed by a method call with params + allows a non object check followed by a method call with params + allows a non object check followed by a method call with params and a block + allows a non object check followed by a method call + ConvertCodeThatCanStartToReturnNil false + registers an offense for an object check followed by a method call with params + registers an offense for an object check followed by a method call with a block + allows a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with params and a block + allows a non-nil object check followed by a method call with a block + allows a non-nil object check followed by a method call + registers an offense for an object check followed by a method calls that nil responds to + allows a non-nil object check followed by a method call with params + registers an offense for an object check followed by a method call + registers an offense for a check for the object followed by a method call in the condition for an if expression + method chaining + corrects an object check followed by a chained method call + corrects an object check followed by a chained method call with a symbol proc + corrects an object check followed by a chained method call with params + corrects an object check followed by a chained method call with a block + ConvertCodeThatCanStartToReturnNil true + registers an offense for a check for the object followed by a method call in the condition for an if expression + corrects an object check followed by a method call and another check + registers an offense for a non-nil object check followed by a method call + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with a block + registers an offense for an object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for a non-nil object check followed by a method call with params and a block + method chaining + registers an offense for an object check followed by chained method calls with blocks + MaxChainLength: 1 + allows an object check followed by 2 chained method calls + registers an offense for an object check followed by 1 chained method calls + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls + allows an object check followed by chained method calls with blocks + MaxChainLength: 3 + allows an object check followed by 4 chained method calls + registers an offense for an object check followed by 3 chained method calls + behaves like all variable types + modifier if + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call with a block safeguarded with a nil check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + registers an offense for a method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a check for the object + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a negative check for the object + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a method call with params safeguarded with a negative nil check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check + if expression + registers an offense for a single method call inside of a check for the object + registers an offense for a single method call with a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of a non-nil check for the object + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with a block inside of an unless nil check for the object + does not lose comments within if expression + only moves comments that fall within the expression + registers an offense for a single method call with params and a block inside of an unless nil check for the object + registers an offense for a single method call with a block inside of an unless negative check for the object + registers an offense for a single method call inside of a non-nil check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call with params and a block inside of an unless negative check for the object + registers an offense for a single method call with params inside of a check for the object + registers an offense for a single method call inside of an unless negative check for the object + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call inside of an unless nil check for the object + registers an offense for a single method call with a block inside of a check for the object + allows a single method call inside of a check for the object with an else + ternary expression + allows ternary expression + object check before method call + allows a nil object check followed by a method call with params and a block + allows a nil object check followed by a method call + allows a non object check followed by a method call with params and a block + allows a non object check followed by a method call with params + allows a non object check followed by a method call + allows a nil object check followed by a method call with a block + allows a non object check followed by a method call with a block + allows a nil object check followed by a method call with params + ConvertCodeThatCanStartToReturnNil true + registers an offense for a check for the object followed by a method call in the condition for an if expression + registers an offense for an object check followed by a method call with a block + registers an offense for an object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for a non-nil object check followed by a method call + registers an offense for a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call + corrects an object check followed by a method call and another check + registers an offense for an object check followed by a method call with params and a block + method chaining + registers an offense for an object check followed by chained method calls with blocks + MaxChainLength: 1 + registers an offense for an object check followed by 1 chained method calls + allows an object check followed by 2 chained method calls + MaxChainLength: 3 + allows an object check followed by 4 chained method calls + registers an offense for an object check followed by 3 chained method calls + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls with blocks + allows an object check followed by chained method calls + ConvertCodeThatCanStartToReturnNil false + registers an offense for an object check followed by a method call with params and a block + allows a non-nil object check followed by a method call with params + registers an offense for an object check followed by a method call with a block + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with params + registers an offense for a check for the object followed by a method call in the condition for an if expression + registers an offense for an object check followed by a method calls that nil responds to + allows a non-nil object check followed by a method call with a block + allows a non-nil object check followed by a method call + allows a non-nil object check followed by a method call with params and a block + method chaining + corrects an object check followed by a chained method call + corrects an object check followed by a chained method call with a symbol proc + corrects an object check followed by a chained method call with a block + corrects an object check followed by a chained method call with params + behaves like all variable types + if expression + does not lose comments within if expression + registers an offense for a single method call inside of an unless negative check for the object + only moves comments that fall within the expression + registers an offense for a single method call inside of a check for the object + registers an offense for a single method call with params inside of a non-nil check for the object + registers an offense for a single method call with params and a block inside of an unless negative check for the object + registers an offense for a single method call with a block inside of a check for the object + registers an offense for a single method call with a block inside of a non-nil check for the object + allows a single method call inside of a check for the object with an else + registers an offense for a single method call with a block inside of an unless negative check for the object + registers an offense for a single method call inside of an unless nil check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + registers an offense for a single method call with params and a block inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call inside of a non-nil check for the object + registers an offense for a single method call with a block inside of an unless nil check for the object + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of a check for the object + ternary expression + allows ternary expression + modifier if + registers an offense for a method call with a block safeguarded with a nil check for the object + registers an offense for a method call with params safeguarded with a check for the object + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a negative nil check for the object + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call safeguarded with a negative check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + object check before method call + allows a non object check followed by a method call with params and a block + allows a nil object check followed by a method call with params and a block + allows a non object check followed by a method call with a block + allows a non object check followed by a method call with params + allows a nil object check followed by a method call + allows a nil object check followed by a method call with a block + allows a non object check followed by a method call + allows a nil object check followed by a method call with params + ConvertCodeThatCanStartToReturnNil false + allows a non-nil object check followed by a method call + allows a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with params and a block + allows a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method calls that nil responds to + allows a non-nil object check followed by a method call with params + registers an offense for an object check followed by a method call with params + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with a block + registers an offense for a check for the object followed by a method call in the condition for an if expression + method chaining + corrects an object check followed by a chained method call with a block + corrects an object check followed by a chained method call with a symbol proc + corrects an object check followed by a chained method call with params + corrects an object check followed by a chained method call + ConvertCodeThatCanStartToReturnNil true + corrects an object check followed by a method call and another check + registers an offense for a non-nil object check followed by a method call with params and a block + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with params and a block + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with a block + registers an offense for an object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call + registers an offense for a check for the object followed by a method call in the condition for an if expression + registers an offense for a non-nil object check followed by a method call with params + method chaining + registers an offense for an object check followed by chained method calls with blocks + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls with blocks + allows an object check followed by chained method calls + MaxChainLength: 1 + allows an object check followed by 2 chained method calls + registers an offense for an object check followed by 1 chained method calls + MaxChainLength: 3 + registers an offense for an object check followed by 3 chained method calls + allows an object check followed by 4 chained method calls + behaves like all variable types + object check before method call + allows a non object check followed by a method call with params and a block + allows a nil object check followed by a method call with params + allows a non object check followed by a method call with params + allows a non object check followed by a method call with a block + allows a non object check followed by a method call + allows a nil object check followed by a method call with a block + allows a nil object check followed by a method call with params and a block + allows a nil object check followed by a method call + ConvertCodeThatCanStartToReturnNil true + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with params + registers an offense for a check for the object followed by a method call in the condition for an if expression + corrects an object check followed by a method call and another check + registers an offense for a non-nil object check followed by a method call + registers an offense for an object check followed by a method call with a block + registers an offense for a non-nil object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with params and a block + method chaining + registers an offense for an object check followed by chained method calls with blocks + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls + allows an object check followed by chained method calls with blocks + MaxChainLength: 1 + allows an object check followed by 2 chained method calls + registers an offense for an object check followed by 1 chained method calls + MaxChainLength: 3 + allows an object check followed by 4 chained method calls + registers an offense for an object check followed by 3 chained method calls + ConvertCodeThatCanStartToReturnNil false + allows a non-nil object check followed by a method call with params + registers an offense for an object check followed by a method calls that nil responds to + registers an offense for an object check followed by a method call + allows a non-nil object check followed by a method call + registers an offense for a check for the object followed by a method call in the condition for an if expression + allows a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with params + allows a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with a block + method chaining + corrects an object check followed by a chained method call + corrects an object check followed by a chained method call with a block + corrects an object check followed by a chained method call with params + corrects an object check followed by a chained method call with a symbol proc + if expression + registers an offense for a single method call inside of a check for the object + registers an offense for a single method call with a block inside of an unless negative check for the object + only moves comments that fall within the expression + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call with params inside of a check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call with a block inside of a check for the object + registers an offense for a single method call with params and a block inside of an unless negative check for the object + allows a single method call inside of a check for the object with an else + registers an offense for a single method call with a block inside of a non-nil check for the object + registers an offense for a single method call inside of an unless nil check for the object + registers an offense for a single method call inside of an unless negative check for the object + registers an offense for a single method call inside of a non-nil check for the object + registers an offense for a single method call with params and a block inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with a block inside of an unless nil check for the object + does not lose comments within if expression + registers an offense for a single method call with params inside of a non-nil check for the object + ternary expression + allows ternary expression + modifier if + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a method call with params safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a method call with a block safeguarded with a nil check for the object + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense for a method call safeguarded with a check for the object + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call with params safeguarded with a check for the object + registers an offense for a method call safeguarded with a negative check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like all variable types + if expression + registers an offense for a single method call inside of an unless nil check for the object + allows a single method call inside of a check for the object with an else + registers an offense for a single method call inside of an unless negative check for the object + registers an offense for a single method call with a block inside of an unless nil check for the object + does not lose comments within if expression + registers an offense for a single method call inside of a non-nil check for the object + registers an offense for a single method call with params inside of a check for the object + registers an offense for a single method call with a block inside of an unless negative check for the object + registers an offense for a single method call with params and a block inside of an unless negative check for the object + registers an offense for a single method call with a block inside of a non-nil check for the object + only moves comments that fall within the expression + registers an offense for a single method call with params and a block inside of a non-nil check for the object + registers an offense for a single method call with params inside of a non-nil check for the object + registers an offense for a single method call with params and a block inside of an unless nil check for the object + registers an offense for a single method call with params inside of an unless negative check for the object + registers an offense for a single method call with a block inside of a check for the object + registers an offense for a single method call with params inside of an unless nil check for the object + registers an offense for a single method call with params and a block inside of a check for the object + registers an offense for a single method call inside of a check for the object + ternary expression + allows ternary expression + object check before method call + allows a non object check followed by a method call with params + allows a non object check followed by a method call + allows a nil object check followed by a method call with params and a block + allows a nil object check followed by a method call with a block + allows a non object check followed by a method call with params and a block + allows a nil object check followed by a method call + allows a nil object check followed by a method call with params + allows a non object check followed by a method call with a block + ConvertCodeThatCanStartToReturnNil true + registers an offense for a check for the object followed by a method call in the condition for an if expression + registers an offense for an object check followed by a method call with params + registers an offense for an object check followed by a method call with a block + corrects an object check followed by a method call and another check + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with params and a block + registers an offense for a non-nil object check followed by a method call + registers an offense for a non-nil object check followed by a method call with a block + registers an offense for a non-nil object check followed by a method call with params + registers an offense for a non-nil object check followed by a method call with params and a block + method chaining + registers an offense for an object check followed by chained method calls with blocks + MaxChainLength: 1 + registers an offense for an object check followed by 1 chained method calls + allows an object check followed by 2 chained method calls + MaxChainLength: 3 + registers an offense for an object check followed by 3 chained method calls + allows an object check followed by 4 chained method calls + with Lint/SafeNavigationChain disabled + allows an object check followed by chained method calls + allows an object check followed by chained method calls with blocks + ConvertCodeThatCanStartToReturnNil false + registers an offense for an object check followed by a method calls that nil responds to + registers an offense for an object check followed by a method call + registers an offense for an object check followed by a method call with params and a block + allows a non-nil object check followed by a method call with params + allows a non-nil object check followed by a method call + registers an offense for a check for the object followed by a method call in the condition for an if expression + allows a non-nil object check followed by a method call with a block + registers an offense for an object check followed by a method call with params + allows a non-nil object check followed by a method call with params and a block + registers an offense for an object check followed by a method call with a block + method chaining + corrects an object check followed by a chained method call + corrects an object check followed by a chained method call with params + corrects an object check followed by a chained method call with a symbol proc + corrects an object check followed by a chained method call with a block + modifier if + registers an offense for an object check followed by a method call with a comment at EOL + registers an offense for a method call with params and a block safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a negative check for the object + registers an offense for a method call with params and a block safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a negative nil check for the object + registers an offense for a method call with params and a block safeguarded with a negative check for the object + registers an offense for a method call that nil responds to safe guarded by an object check + registers an offense for a method call safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a nil check for the object + registers an offense for a method call with params and a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a negative nil check for the object + registers an offense for a method call safeguarded with a check for the object + registers an offense for a chained method call safeguarded with a negative nil check for the object + registers an offense for a chained method call safeguarded with an unless nil check for the object + registers an offense for a chained method call safeguarded with a check for the object + registers an offense for a method call on an accessor safeguarded by a check for the accessed variable + registers an offense for a method call with a block safeguarded with a negative check for the object + registers an offense when safe guard check and safe navigation method call are connected with `&&` condition + registers an offense for a method call with params safeguarded with a nil check for the object + registers an offense for a method call with a block safeguarded with a check for the object + registers an offense for a method call with params safeguarded with a negative check for the object + registers an offense for a method call with params safeguarded with a check for the object + registers an offense for a method call with a block safeguarded with a nil check for the object + behaves like safe guarding logical break keywords + allows a method call being passed to next safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to break safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to return safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to throw safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to yield safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to fail safe guarded by an object check + behaves like safe guarding logical break keywords + allows a method call being passed to raise safe guarded by an object check -RuboCop::Cop::Lint::RequireRangeParentheses - does not register an offense when begin and end of the range are on the same line - does not register an offense when the end of the range (`..`) is line break and is enclosed in parentheses - registers an offense when the end of the range (`...`) is line break - registers an offense when the end of the range (`..`) is line break - does not register an offense when using `nil..42` - does not register an offense when using `42..nil` - Ruby >= 2.7 - does not register an offense when using beginless range only - Ruby >= 2.6 - does not register an offense when using endless range only +RuboCop::Cop::Style::MethodCallWithoutArgsParentheses + registers an offense for `obj.method += func()` + accepts special lambda call syntax + accepts parentheses for methods starting with an upcase letter + accepts parens after not + accepts parens in method call with args + registers an offense for `obj.method ||= func()` + autocorrects calls that could be empty literals + registers an offense for parens in method call without args + registers an offense for `obj.method &&= func()` + when AllowedPatterns is enabled + ignores method listed in AllowedMethods + assignment to a variable with the same name + accepts parens in shorthand assignment + accepts parens in parallel assignment + accepts parens in complex assignment + accepts parens in default argument assignment + accepts parens in local variable assignment + method call as argument + accepts without parens + registers an empty parens offense for multiple assignment + registers an offense with empty parens + when AllowedMethods is enabled + ignores method listed in AllowedMethods -RuboCop::Cop::Style::MethodCallWithArgsParentheses - when inspecting macro methods with IncludedMacros - in a module body - finds offense - for a macro not on the included list - allows - behaves like endless methods - endless methods - with arguments - requires method calls to have parens - without arguments - does not register an offense when there are arguments - does not register an offense when there are no parens - does not register an offense when there are parens - does not register an offense for `defs` when there are arguments - does not register an offense for `defs` when there are parens - in a class body - finds offense - for a macro in both IncludedMacros and AllowedMethods - allows - allowing parens in string interpolation - accepts parens for camel-case method names - when EnforcedStyle is require_parentheses (default) - register an offense for methods starting with capital without parens - register an offense for yield without parens - accepts parens in method call with args - accepts no parens in method call without args - autocorrects calls where the argument node is a number - accepts no parens for unary operators - register no offense for superclass call with parens - autocorrects fully parenthesized args by removing space - autocorrects partially parenthesized args by adding needed braces - autocorrects parenthesized args for local methods by removing space - autocorrects call with multiple args by adding braces - autocorrects calls where the argument node is a constant - register an offense for non-receiver method call without parens - autocorrects calls where multiple args are method calls - register no offense for superclass call without args - register no offense for yield without args - register an offense for method call without parens - accepts no parens for operators - autocorrects calls where arg is method call - autocorrects calls with multiple args by adding needed braces - accepts no parens for setter methods - register an offense for superclass call without parens - accepts parens in method call with do-end blocks - AllowedPatterns - ignored methods listed in AllowedPatterns - with AllowedMethods - allow method listed in AllowedMethods - behaves like endless methods - endless methods - with arguments - requires method calls to have parens - without arguments - does not register an offense when there are parens - does not register an offense for `defs` when there are parens - does not register an offense for `defs` when there are arguments - does not register an offense when there are arguments - does not register an offense when there are no parens - when using safe navigation operator - register an offense for method call without parens - when inspecting macro methods - in a class body - does not register an offense - in a module body - does not register an offense - when EnforcedStyle is omit_parentheses - register an offense in assignments - accepts parens in single-line inheritance - accepts special lambda call syntax - accepts parens in slash regexp literal as argument - accepts parens in args with ternary conditions - accepts parens in splat calls - register an offense for superclass call with parens - accepts parens in super method calls as arguments - accepts parens in default argument value calls - register an offense for parens in string interpolation - accepts parens in default keyword argument value calls - accepts parens in yield argument method calls - accepts parens in super calls with braced blocks - accepts parens in chaining with operators - register an offense for parens in do-end blocks - accepts parens in chaining with safe operators - register an offense for camel-case methods with arguments - register an offense in complex conditionals - accepts parens in assignment in conditions - accepts parens in blocks with braces - accepts parens in chained method calls - accepts parens in method args - autocorrects single-line calls - accepts parens in nested method args - register an offense for yield call with parens - accepts parens in block passing calls - accepts parens in literals with unary operators as first argument - accepts parens in super without args - register an offense for parens in method call without args - accepts no parens in method call without args - accepts parens in calls with hash as arg - accepts parens in implicit #to_proc - accepts parens in operator method calls - autocorrects complex multi-line calls - register an offense for parens in the last chain - accepts parens in args splat - register an offense for %r regex literal as arguments - accepts parens in range literals - accepts parens in calls with args with logical operators - accepts parens in ternary condition calls - register an offense for hashes in keyword values - autocorrects multi-line calls with trailing whitespace - accepts no parens in method call with args - register an offense in multi-line inheritance - accepts parens in argument calls with braced blocks - register an offense for multi-line method calls - accepts parens in calls with logical operators - accepts parens in camel case method without args - allowing parens in multi-line calls - accepts parens for multi-line calls - allowing parens in camel-case methods - accepts parens for camel-case method names - forwarded arguments in 2.7 - accepts parens for forwarded arguments - numbered parameters in 2.7 - accepts parens for braced numeric block calls - allowing parenthesis in chaining - register offense for single-line chaining without previous parens - register offense for multi-line chaining without previous parens - accepts parens in the last call if any previous calls with parentheses - accepts no parens in the last call if previous calls with parens - hash value omission in 3.1 - registers an offense when last argument is a hash value omission - does not register an offense when without parentheses call expr follows - does not register an offense when hash value omission with parentheses and using modifier form - registers an offense using assignment with parentheses call expr follows - registers and corrects an offense when explicit hash value with parentheses and using modifier form - registers an offense when with parentheses call expr follows - behaves like endless methods - endless methods - with arguments - requires method calls to have parens - without arguments - registers an offense when there are parens - registers an offense for `defs` when there are parens - does not register an offense when there are arguments - does not register an offense for `defs` when there are arguments - does not register an offense when there are no parens - forwarded arguments in 3.0 - accepts parens for forwarded arguments +RuboCop::Cop::Style::SignalException + when enforced style is `fail` + accepts `raise` with explicit receiver + registers an offense for `raise` with `Kernel` as explicit receiver + registers an offense for raise in begin section + registers an offense for raise in rescue section + registers an offense for raise in def body + when enforced style is `semantic` + is not confused by nested begin/rescue + registers one offense for each raise + registers an offense for `raise` and `fail` with `::Kernel` as explicit receiver + registers only offense for one raise that should be fail + registers an offense for fail in second rescue + registers an offense for `raise` and `fail` with `Kernel` as explicit receiver + registers an offense for raise not in a begin/rescue/end + accepts raise in def rescue section + registers an offense for fail in rescue section + accepts raise in rescue section + accepts `raise` and `fail` with explicit receiver + registers an offense for raise in begin section + accepts raise in def with multiple rescues + registers an offense for fail in def rescue section + registers an offense for raise in def body + when enforced style is `raise` + accepts `fail` with explicit receiver + registers an offense for fail in begin section + accepts `fail` if a custom `fail` instance method is defined + registers an offense for `fail` with `Kernel` as explicit receiver + registers an offense for fail in rescue section + accepts `fail` if a custom `fail` singleton method is defined + registers an offense for fail in def body -RuboCop::ConfigRegeneration - #options - it parses options from the generation comment - is expected to eq {:auto_gen_config=>true, :auto_gen_only_exclude=>true, :auto_gen_timestamp=>false, :exclude_limit=>"100", :offense_counts=>false} - when there is a blank todo file - is expected to eq {:auto_gen_config=>true} - when no todo file exists - is expected to eq {:auto_gen_config=>true} - when the todo file is malformed - is expected to eq {:auto_gen_config=>true} +RuboCop::Cop::InternalAffairs::CreateEmptyFile + does not register an offense when using `create_file(path, ['foo', 'bar'])` + does not register an offense when using `create_file(path)` + does not register an offense when using `receiver.create_file(path, '')` + registers an offense when using `create_file(path, '') + registers an offense when using `create_file(path, "") + does not register an offense when using `create_file(path, 'hello')` -RuboCop::Cop::Style::UnlessElse - unless without else - does not register an offense - unless with else - registers an offense - and nested unless with else - registers offenses for both but corrects only the outer unless/else - unless with nested if-else +RuboCop::Cop::Lint::DuplicateHashKey + behaves like duplicated non literal key + does not register an offense for duplicated `%r{abx#{foo}}ixo` hash keys + behaves like duplicated literal key + registers an offense for duplicated `1.0` hash keys + behaves like duplicated literal key + registers an offense for duplicated `nil` hash keys + behaves like duplicated literal key + registers an offense for duplicated `(false <=> true)` hash keys + behaves like duplicated literal key + registers an offense for duplicated `/./` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `[some_method_call]` hash keys + behaves like duplicated literal key + registers an offense for duplicated `[1, 2, 3]` hash keys + behaves like duplicated literal key + registers an offense for duplicated `!true` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `{ :sym => some_method_call }` hash keys + behaves like duplicated literal key + registers an offense for duplicated `false` hash keys + when there are two duplicated keys in a hash + registers two offenses + behaves like duplicated literal key + registers an offense for duplicated `{ :a => 1, :b => 2 }` hash keys + behaves like duplicated literal key + registers an offense for duplicated `'str'` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `(x == false)` hash keys + behaves like duplicated literal key + registers an offense for duplicated `1` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `(x && false)` hash keys + behaves like duplicated literal key + registers an offense for duplicated `(false && true)` hash keys + When a key is duplicated three times in a hash literal + registers two offenses + behaves like duplicated non literal key + does not register an offense for duplicated `(x or false)` hash keys + behaves like duplicated literal key + registers an offense for duplicated `(false or true)` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `"#{some_method_call}"` hash keys + behaves like duplicated literal key + registers an offense for duplicated `(1)` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `/.#{some_method_call}/` hash keys + target ruby version >= 2.6 + behaves like duplicated literal key + registers an offense for duplicated `(42..)` hash keys + when there is a duplicated key in the hash literal registers an offense + behaves like duplicated non literal key + does not register an offense for duplicated `some_method_call` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `{ some_method_call => :sym }` hash keys + behaves like duplicated literal key + registers an offense for duplicated `"#{2}"` hash keys + behaves like duplicated non literal key + does not register an offense for duplicated `some_method_call(x, y)` hash keys + When there is no duplicated key in the hash + does not register an offense + behaves like duplicated literal key + registers an offense for duplicated `%r{abx}ixo` hash keys + behaves like duplicated literal key + registers an offense for duplicated `{ a: 1, b: 2 }` hash keys -RuboCop::Cop::Layout::FirstArrayElementLineBreak - ignores elements listed on a single line - ignores properly formatted implicit arrays - masgn implicit arrays - registers and corrects the offense - array nested in a method call - registers an corrects the offense - send implicit arrays - registers and corrects the offense - word arrays - registers and corrects the offense - elements listed on the first line - registers and corrects the offense - -RuboCop::Cop::Layout::FirstMethodParameterLineBreak - accepts single-line methods - accepts params listed on a single line - registers an offense and corrects params on first line of singleton method - accepts params without parens - registers an offense and corrects params listed on the first line - accepts methods without params - registers an offense and corrects params with default values - -RuboCop::Cop::Lint::EmptyWhen - when a `when` body is missing - registers an offense for a missing when body - registers an offense for missing when body with a comment followed by else - registers an offense for missing when ... then body - registers an offense for missing when body followed by else - registers an offense for missing when body with a comment - registers an offense when case line has no expression - registers an offense for missing when ... then body followed by else - when `AllowComments: false` - registers an offense for empty when body with a comment - when a `when` body is present - accepts with no case line expression - accepts case with when bodies - accepts case with when ... then statements - accepts case with when ... then statements and else clause - accepts case with when bodies and else clause - when `AllowComments: true` - accepts an empty when ... then body with a comment - registers an offense for missing when body without a comment - accepts an empty when body with a comment - -RuboCop::Cop::Layout::FirstParameterIndentation - consistent style - valid indentation on multi-line defs - accepts correctly indented first element - accepts correctly indented first element hash - no paren method defs - ignores with hash args - ignores - single line method defs - ignores - ignores with hash args - invalid indentation on multi-line defs - normal arguments - registers an offense and corrects incorrectly indented first element - hash arguments - registers an offense and corrects incorrectly indented first element - hash arguments static method def - registers an offense and corrects incorrectly indented first element - valid indentation on static multi-line defs - accepts correctly indented first element hash - accepts correctly indented first element - align_parentheses style - single line method defs - ignores with hash args - ignores - no paren method defs - ignores - ignores with hash args - invalid indentation on multi-line defs - hash arguments static def - registers an offense and corrects incorrectly indented first element - normal arguments - registers an offense and corrects incorrectly indented first element - hash arguments - registers an offense and corrects incorrectly indented first element - valid indentation on multi-line defs - accepts correctly indented first element - accepts correctly indented first element hash - -RuboCop::Cop::Style::NegatedIf - does not blow up for ternary ops - does not blow up for empty unless condition - does not blow up for empty if condition - does not blow up on a negated ternary operator - with “both” style - autocorrects by replacing parenthesized if not with unless - registers an offense for if with "not" condition - is not confused by negated elsif - registers an offense for if with exclamation point condition - accepts an if where the condition is doubly negated - accepts an if where only part of the condition is negated - accepts an if/else with negative condition - with “prefix” style - does not register an offense for postfix - registers an offense for prefix - with “postfix” style - does not register an offense for prefix - registers an offense for postfix +RuboCop::Runner + #run when interrupted + with SIGINT + returns false + #run with cops autocorrecting each-other + with two pairs of conflicting cops + with display options + --display-only-safe-correctable + returns false + ommits unsafe correctable `Style/FrozenStringLiteral` + --display-only-correctable + ommits uncorrectable `Layout/LineLength` + returns false + with three cop cycle + if there is an offense in an inspected file + aborts because of an infinite loop + if there is an offense in an inspected file + aborts because of an infinite loop + with two conflicting cops + if there are multiple offenses in an inspected file + aborts because of an infinite loop + if there is an offense in an inspected file + aborts because of an infinite loop + #run + if there is an offense in an inspected file + sends the offense to a formatter + returns false + if there are no offenses in inspected files + returns true + if -s/--stdin is used with an offense + returns false + sends the offense to a formatter + if a cop crashes + does not call ResultCache#save -RuboCop::Cop::Style::OpenStructUse - when not using OpenStruct - registers no offense - when using OpenStruct - for ::OpenStruct - when used in assignments - registers an offense - when inheriting from it via Class.new - registers an offense - when inheriting from it via < - registers an offense - for OpenStruct - when inheriting from it via < - registers an offense - when used in assignments - registers an offense - when inheriting from it via Class.new - registers an offense - when using custom namespaced OpenStruct - when inheriting from it - is expected to eq "class A < SomeNamespace::OpenStruct; end" - when defined in custom namespace - when class - is expected to eq "module SomeNamespace\n class OpenStruct\n end\nend\n" - when module - is expected to eq "module SomeNamespace\n module OpenStruct\n end\nend\n" - when used in assignments - registers no offense +RuboCop::Cop::Style::MultilineTernaryOperator + registers an offense and corrects when everything is on a separate line + registers an offense and corrects when condition is multiline + registers offense and corrects when the if branch and the else branch are on a separate line from the condition + register an offense and corrects when returning a multiline ternary operator expression with method call + registers an offense and corrects when the false branch is on a separate line + accepts a single line ternary operator expression + registers an offense and corrects when the false branch is on a separate line and assigning a return value + registers an offense and corrects when condition is multiline and using hash key assignment + registers an offense and corrects when condition is multiline and using assignment method + register an offense and corrects when returning a multiline ternary operator expression with `break` + register an offense and corrects when returning a multiline ternary operator expression with `return` + register an offense and corrects when returning a multiline ternary operator expression with `next` -RuboCop::Cop::Style::NilComparison - configured with predicate preferred - registers an offense for == nil - registers and corrects an offense when using `x == nil` as a guard condition - registers an offense for === nil - configured with comparison preferred - registers and corrects an offense for `!x.nil?` - registers an offense for nil? +RuboCop::Cop::Layout::SpaceBeforeBrackets + does not register an offense when using percent array literal argument without parentheses + does not register an offense when assigning an array + does not register an offense when using array literal argument without parentheses + when referencing + does not register an offense when without receiver + does not register an offense when not using space between variable receiver and left brackets + does not register an offense when not using space between method call and left brackets + does not register an offense when call desugared `Hash#[]` to ivar receiver + registers an offense and corrects when using space between gvar receiver and left brackets + does not register an offense when using multiple arguments + does not register an offense when call desugared `Hash#[]` to cvar receiver + does not register an offense when it is used as a method argument + does not register an offense when array literal argument is enclosed in parentheses + does not register an offense when using space between method call and left brackets + registers an offense and corrects when using space between ivar receiver and left brackets + registers an offense and corrects when using space between cvar receiver and left brackets + registers an offense and corrects when using space between lvar receiver and left brackets + does not register an offense when call desugared `Hash#[]` to lvar receiver + when assigning + does not register an offense when not using space between receiver and left brackets + does not register an offense when space is used in left bracket + registers an offense and corrects when using space between receiver and left brackets + does not register an offense when multiple spaces are inserted inside the left bracket -RuboCop::Cop::Generator::RequireFileInjector - when using an unknown department - inserts a `require_relative` statement to the bottom of the file - when a `require_relative` entry does not exist from before - injects a `require_relative` statement on the right line in the root file - when a `require` entry already exists - does not write to any file - when a cop of style department already exists - injects a `require_relative` statement on the end of style department +RuboCop::Cop::Style::RedundantBegin + does not register an offense when using `begin` with `rescue` + accepts a def with required begin block + doesn't modify spacing when autocorrecting + autocorrects when there are trailing comments + reports an offense when multi-line `begin` block has single statement and it is inside condition + does not register an offense when using `begin` for semantic operator conditions + does not register an offense when using `begin` with multiple statement for or assignment + accepts a defs with required begin block + does not register an offense when using `begin` for assignment + does not register an offense when using `begin` with `until` + registers and corrects an offense when using `begin` with single statement for or assignment + registers an offense and corrects when using `begin` without `rescue` or `ensure` + registers and corrects an offense when using multi-line `if` in `begin` block + does not register an offense when using `begin` with `while` + does not register an offense when using `begin` for method argument + does not register an offense when using `begin` with no statements for or assignment + reports an offense when assigning nested `begin` blocks + registers and corrects an offense when using modifier `if` single statement in `begin` block + does not register an offense when using `begin` for or assignment and method call + does not register an offense when using body of `begin` is empty + accepts a def with a begin block after a statement + registers and corrects an offense when using `begin` with single statement that called a block for or assignment + reports an offense for def with redundant begin block + does not register an offense when using `begin` for logical operator conditions + reports an offense for single line def with redundant begin block + reports an offense for defs with redundant begin block + reports an offense when multi-line `begin` block has single statement with modifier condition + accepts when one-liner `begin` block has multiple statements with modifier condition + accepts when multi-line `begin` block has multiple statements with modifier condition + reports an offense when one-liner `begin` block has single statement with modifier condition + does not register an offense when using `begin` with `ensure` + reports an offense when assigning nested blocks which contain `begin` blocks + >= ruby 2.5 + accepts a {} block with a begin-end + accepts super with block + accepts a stabby lambda with a begin-end + accepts a block with a begin block after a statement + registers an offense for a do-end block with redundant begin-end + when using endless method definition + registers when `begin` block has a single statement + accepts when `begin` block has multiple statements + accepts when `begin` block has no statements + < Ruby 2.5 + accepts a do-end block with a begin-end + Ruby 2.7 + reports an offense when assigning nested blocks which contain `begin` blocks -RuboCop::Cop::Style::CharacterLiteral - registers an offense for literals like \n - accepts ? in a %w literal - accepts literals like ?\C-\M-d - registers an offense for character literals - autocorrects ?' to "'" +RuboCop::Cop::Style::NumericLiteralPrefix + hex literals + registers an offense for uppercase prefix + does not register offense for lowercase prefix + binary literals + does not register offense for lowercase prefix + registers an offense for uppercase prefix + octal literals + when config is zero_with_o + registers an offense for prefixes `0` and `0O` + does not register offense for lowercase prefix + when config is zero_only + does not register offense for prefix `0` + registers an offense for prefix `0O` and `0o` + decimal literals + does not register offense for no prefix + registers an offense for prefixes -RuboCop::Cop::Style::MixinGrouping - when configured with grouped style - when using `extend` - registers an offense for single mixins in separate calls - when using include - allows include with an explicit receiver - registers an offense for single mixins in separate calls - registers an offense for several mixins in separate calls - when using `prepend` - registers an offense when other mixins have receivers - registers an offense for single mixins in separate calls, interspersed - registers an offense for single mixins in separate calls - when using a mix of diffent methods - registers an offense with some duplicated mixin methods - allows all different mixin methods - when configured with separated style - when using `include` - registers an offense for several mixins in separate calls - registers an offense for several mixins in one call - allows include call as an argument to another method - when using `prepend` - registers an offense for several mixins in one call - when using a mix of diffent methods - registers an offense for some calls having several mixins - when using `extend` - registers an offense for several mixins in one call +RuboCop::Cop::Style::EmptyHeredoc + registers an offense when using empty `<= Ruby 2.6 - `map` without `to_h` - does not register an offense - for `map.to_h` with block arity 1 - registers an offense and corrects - `collect.to_h` with a block on `to_h` - registers an offense but does not correct - `map` and `collect.to_h` with newlines - registers an offense and corrects with newline removal - when the receiver is an array - registers an offense and corrects - for `map.to_h` with block arity 2 - registers an offense and corrects - for `collect.to_h` with block arity 1 - registers an offense and corrects - `map.to_h` with a block on `to_h` - registers an offense but does not correct - `map` and `map.to_h` with newlines - registers an offense and corrects with newline removal - when the receiver is an array +RuboCop::Cop::Layout::EmptyLineBetweenDefs + finds offenses in inner classes + autocorrects when there are too many new lines + treats lines with whitespaces as blank + accepts a def that follows an empty line and then a comment + registers an offense for adjacent one-liners by default + accepts a def that is the first of a module + accepts a nested def + registers an offense for multiple one-liners on the same line + accepts the first def without leading empty line in a class + doesn't allow more than the required number of newlines + accepts a def that follows a line with code + accepts a def that follows code and a comment + when empty lines between classes and modules together + registers offense when no empty lines between module and method definitions + EmptyLineBetweenModuleDefs + registers offense when no empty lines between module and method definitions + when disabled + does not register offense + when there are only comments between defs + registers an offense + conditional method definitions + registers an offense for consecutive defs inside a conditional + accepts defs inside a conditional without blank lines in between + class methods + adjacent class methods + registers an offense for missing blank line between methods + mixed instance and class methods + registers an offense for missing blank line between methods + when multiple lines between defs are allowed + registers an offense and corrects when there are too many new lines + treats lines with whitespaces as blank + when AllowAdjacentOneLineDefs is enabled + registers an offense for adjacent defs if some are multi-line + accepts adjacent one-liners + EmptyLineBetweenClassDefs + registers offense when no empty lines between class and method definitions + with AllowAdjacentOneLineDefs enabled + does not register offense + when disabled + does not register offense + when a maximum of empty lines is specified + finds no offense for no empty line + finds no offense for one empty line + finds an offense for two empty lines + endless methods + between regular and endless methods registers an offense and corrects - for `collect.to_h` with block arity 2 + with AllowAdjacentOneLineDefs: false registers an offense and corrects - when the receiver is an hash + between endless class method and regular class methods registers an offense and corrects - when the receiver is an hash + between endless class method and regular methods registers an offense and corrects - `collect` without `to_h` + with AllowAdjacentOneLineDefs: true does not register an offense - when chained further - registers an offense and corrects - when chained further + between endless and regular methods registers an offense and corrects -RuboCop::Cop::Lint::MultipleComparison - registers an offense for x < y <= z - accepts to use `&` operator - registers an offense for x < y > z - registers an offense for x >= y <= z - registers an offense for x < y >= z - registers an offense for x >= y > z - accepts to use one compare operator - registers an offense for x >= y >= z - accepts to use `|` operator - registers an offense for x > y > z - registers an offense for x > y < z - registers an offense for x > y >= z - registers an offense for x > y <= z - registers an offense for x <= y > z - registers an offense for x <= y < z - registers an offense for x <= y >= z - registers an offense for x <= y <= z - registers an offense for x < y < z - accepts to use `^` operator - registers an offense for x >= y < z - -RuboCop::Cop::Style::FileWrite - registers an offense for and corrects `File.open(filename, 'w+b').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+b') with heredoc - registers an offense for and corrects the `File.open` with inline write block (mode 'w+b') - does not register an offense for the `File.open` with multiline write block when not writing to the block variable - registers an offense for and corrects the `File.open` with multiline write block (mode 'w') - registers an offense for and corrects the `File.open` with inline write block (mode 'w') - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+t') with heredoc - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+') - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+t') - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+') with heredoc - registers an offense for and corrects the `File.open` with inline write block (mode 'w+t') - registers an offense for and corrects `File.open(filename, 'w+').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'w+b') - does not register an offense when a splat argument is passed to `f.write` - registers an offense for and corrects the `File.open` with inline write block (mode 'w+') - registers an offense for and corrects `File.open(filename, 'w').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'wb') - registers an offense for and corrects the `File.open` with multiline write block (mode 'w') with heredoc - registers an offense for and corrects `::File.open(filename, 'w').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'wt') with heredoc - registers an offense for and corrects `::File.open(filename, 'wb').write(content)` - registers an offense for and corrects `::File.open(filename, 'w+b').write(content)` - registers an offense for and corrects `File.open(filename, 'wb').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'wb') with heredoc - registers an offense for and corrects `::File.open(filename, 'wt').write(content)` - registers an offense for and corrects `File.open(filename, 'wt').write(content)` - registers an offense for and corrects the `File.open` with inline write block (mode 'wt') - registers an offense for and corrects `File.open(filename, 'w+t').write(content)` - registers an offense for and corrects `::File.open(filename, 'w+t').write(content)` - registers an offense for and corrects the `File.open` with multiline write block (mode 'wt') - registers an offense for and corrects `::File.open(filename, 'w+').write(content)` - registers an offense for and corrects the `File.open` with inline write block (mode 'wb') - -RuboCop::Cop::Style::NumberedParametersLimit - with Ruby >= 2.7 - sets Max properly for auto-gen-config - does not register an offense for a numblock with exactly `Max` parameters - does not register an offense for a normal block with too many parameters - does not register an offense for a numblock with fewer than `Max` parameters - when Max is 1 - uses the right offense message - when there are more than `Max` numbered parameters - registers an offense for a multiline `numblock` - registers an offense for a single line `numblock` - when configuring Max - does not register an offense when there are not too many numbered params +RuboCop::Cop::Style::ClassCheck + when enforced style is kind_of? + registers an offense for is_a? and corrects to kind_of? + when enforced style is is_a? + registers an offense for kind_of? and corrects to is_a? -RuboCop::Cop::Layout::ConditionPosition - registers an offense and corrects for condition on the next line - accepts condition on the same line - accepts condition on a different line for modifiers - registers an offense and corrects for condition on the next line - accepts condition on the same line - accepts condition on a different line for modifiers - registers an offense and corrects for condition on the next line - accepts condition on a different line for modifiers - accepts condition on the same line - registers an offense and corrects for condition on the next line - accepts condition on a different line for modifiers - accepts ternary ops - registers an offense and corrects for elsif condition on the next line - accepts condition on the same line +RuboCop::Cop::Style::StructInheritance + accepts plain class + registers an offense when extending instance of Struct without `do` ... `end` and class body is empty + accepts assignment to block form of Struct.new + accepts assignment to ::Struct.new + registers an offense when extending instance of Struct without `do` ... `end` and class body is empty and single line definition + accepts assignment to Struct.new + registers an offense when extending instance of ::Struct + registers an offense when extending instance of ::Struct with do ... end + registers an offense when extending instance of Struct + registers an offense when extending instance of `Struct` when there is a comment before class declaration + registers an offense when extending instance of Struct with do ... end + accepts extending DelegateClass -RuboCop::Cop::Style::SignalException - when enforced style is `fail` - registers an offense for raise in begin section - accepts `raise` with explicit receiver - registers an offense for raise in def body - registers an offense for raise in rescue section - registers an offense for `raise` with `Kernel` as explicit receiver - when enforced style is `semantic` - registers an offense for fail in rescue section - registers an offense for raise in begin section - accepts raise in def with multiple rescues - registers an offense for `raise` and `fail` with `::Kernel` as explicit receiver - is not confused by nested begin/rescue - registers only offense for one raise that should be fail - accepts `raise` and `fail` with explicit receiver - registers an offense for fail in def rescue section - registers an offense for fail in second rescue - registers one offense for each raise - registers an offense for raise not in a begin/rescue/end - accepts raise in rescue section - accepts raise in def rescue section - registers an offense for raise in def body - registers an offense for `raise` and `fail` with `Kernel` as explicit receiver - when enforced style is `raise` - registers an offense for fail in def body - accepts `fail` if a custom `fail` singleton method is defined - registers an offense for fail in begin section - accepts `fail` with explicit receiver - registers an offense for fail in rescue section - registers an offense for `fail` with `Kernel` as explicit receiver - accepts `fail` if a custom `fail` instance method is defined +RuboCop::Cop::Layout::MultilineMethodParameterLineBreaks + when there are multiple parameters on the first line + registers an offense and corrects starting from the 2nd argument + when there are no parameters + does not add any offenses + when one parameter on same line + does not add any offenses + when many parameters including hash are on multiple lines, three on same line + registers an offense and corrects + when parameter's default value starts on same line but ends on different line + registers an offense and corrects + when many parameter are on multiple lines, two on same line + registers an offense and corrects + when second parameter starts on same line as end of first + registers an offense and corrects + when many parameters are on multiple lines, three on same line + registers an offense and corrects + when two parameters are on next line + does not add any offenses -RuboCop::Cop::Lint::ShadowedArgument - block argument shadowing - when a single argument is shadowed +RuboCop::Cop::Style::Lambda + when using safe navigation operator + does not break + with enforced `literal` style + with a multiline lambda method call + without arguments + registers an offense + with arguments + registers an offense + with a single line lambda method call + without arguments + registers an offense + with arguments + registers an offense + with default `line_count_dependent` style + with a multiline lambda literal as an argument registers an offense - when binding is used + unusual lack of spacing + without spacing after arguments registers an offense - when IgnoreImplicitReferences config option is set to true - accepts - and the argument is not used - accepts - and shadowed within a block - registers an offense without specifying where the reassignment took place - and the block occurs after the reassignment + without spacing before arguments + registers an offense + without any spacing + registers an offense + with a multiline lambda literal + with no parentheses and many args registers an offense - and the block is nested within a conditional - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and the block is nested within a block - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and was used before shadowing - accepts - and the argument was not shadowed outside the block - accepts - when zsuper is used - accepts - and shadowed within a conditional - registers an offense without specifying where the reassignment took place - and the conditional is nested within a lambda - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and the conditional occurs after the reassignment + with no arguments and bad spacing registers an offense - and the conditional is nested within a conditional - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and the argument was not shadowed outside the conditional - accepts - and was used before shadowing - accepts - when a block local variable is assigned but no argument is shadowed - accepts - when multiple arguments are shadowed - and one of them shadowed within a lambda while another is shadowed outside - registers an offense - method argument shadowing - when a single argument is shadowed + with no parentheses and bad spacing + registers an offense + with empty arguments + registers an offense + without parentheses + registers an offense + with no arguments and no spacing + registers an offense + with a multiline lambda method call + does not register an offense + with a multiline do-end lambda as a parenthesized kwarg registers an offense - when argument was used in shorthand assignment - does not register an offense - and shadowed within a block - registers an offense without specifying where the reassignment took place - and the block is nested within a block - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and the argument was not shadowed outside the block - accepts - and the block occurs after the reassignment + >= Ruby 2.7 + when using numbered parameter + with a multiline lambda method call + does not register an offense + with a single line lambda method call registers an offense - and the block is nested within a conditional - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and was used before shadowing - accepts - when a splat argument is shadowed + with a single line lambda literal + does not register an offense + with a multiline lambda literal + with arguments registers an offense - when binding is used + without arguments registers an offense - when IgnoreImplicitReferences config option is set to true - accepts - and shadowed within a conditional - registers an offense without specifying where the reassignment took place - and the argument was not shadowed outside the conditional - accepts - and was used before shadowing - accepts - and the conditional occurs after the reassignment - registers an offense - and the conditional is nested within a lambda - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - and the conditional is nested within a conditional - registers an offense without specifying where the reassignment took place - and the argument was used before shadowing - accepts - when zsuper is used + with a single line lambda method call + without arguments registers an offense - when IgnoreImplicitReferences config option is set to true - accepts - when argument was shadowed by zsuper - does not register an offense - when argument was shadowed by zsuper - registers an offense - and the argument is not used - accepts - when reassigning to splat variable + with arguments + registers an offense + with a multiline do-end lambda literal as a keyword argument + registers an offense + with a single line lambda literal + does not register an offense + when calling a lambda method without a block + does not register an offense + with a multiline braces lambda literal as a keyword argument + registers an offense + with enforced `lambda` style + with a multiline lambda literal + without arguments + registers an offense + with arguments + registers an offense + with a single line lambda literal + without argument parens and spaces + registers an offense + without arguments + registers an offense + with arguments + registers an offense + +RuboCop::Cop::Metrics::BlockLength + rejects brace blocks too + accepts empty blocks + properly counts nested blocks + does not count blank lines + rejects a block with more than 5 lines + reports the correct beginning and end lines + accepts a block with less than 3 lines + accepts a block with multiline receiver and less than 3 lines of body + does not count commented lines by default + when using numbered parameter + does not count blank lines + reports the correct beginning and end lines + rejects a block with more than 5 lines + accepts a block with less than 3 lines + when CountComments is enabled + also counts commented lines + when methods to allow are defined + when IgnoredMethods is enabled + when string + does not report an offense + that does not match + reports an offense + when regex + does not report an offense + that does not match + reports an offense + when AllowedPatterns is enabled + does not report an offense + that does not match + reports an offense + when ExcludedMethods is enabled + does not report an offense + that does not match + reports an offense + when AllowedMethods is enabled + when a method is allowed, but receiver is a module + does not report an offense + behaves like allow an offense on an allowed method + accepts the foo method with a long block + still rejects other methods with long blocks + behaves like allow an offense on an allowed method + accepts the foo method with a long block + still rejects other methods with long blocks + when receiver contains whitespaces + allows whitespaces + when defining a Struct + does not register an offense + when `CountAsOne` is not empty + folds array into one line + when defining a class + does not register an offense + when defining a module + does not register an offense + +RuboCop::Cop::Style::WhileUntilModifier + behaves like condition modifier cop + for a multiline 'until' + accepts it if single line would not fit on one line + handles inline comments during autocorrection + accepts it if body spans more than one line + doesn't break when used as RHS of constant assignment + handles one-line usage + corrects it if result fits in one line + accepts it when condition has local variable assignment + accepts an empty body + doesn't break when used as RHS of class var assignment + doesn't break when used as RHS of local var assignment + corrects it when assignment is in body + doesn't break when used as RHS of instance var assignment + doesn't break when used as RHS of binary arithmetic + accepts multiline condition in modifier form + registers an offense + when Layout/LineLength is disabled + registers an offense even for a long modifier statement + when there is a comment on the first line and some code after the end keyword does not register an offense - when multiple arguments are shadowed - and one of them shadowed within a lambda while another is shadowed outside + behaves like condition modifier cop + for a multiline 'while' + handles inline comments during autocorrection + handles one-line usage + doesn't break when used as RHS of class var assignment + accepts it if single line would not fit on one line + doesn't break when used as RHS of instance var assignment + doesn't break when used as RHS of binary arithmetic + accepts it if body spans more than one line + corrects it when assignment is in body + accepts an empty body + corrects it if result fits in one line + doesn't break when used as RHS of constant assignment + accepts it when condition has local variable assignment + doesn't break when used as RHS of local var assignment + accepts multiline condition in modifier form registers an offense + when there is a comment on the first line and some code after the end keyword + does not register an offense + when Layout/LineLength is disabled + registers an offense even for a long modifier statement -RuboCop::Cop::Lint::LiteralInInterpolation - accepts interpolation of erange where endpoints are not literals - does not register an offense when space literal at the end of heredoc line - handles double quotes in single quotes when autocorrecting - handles backslash in single quotes when autocorrecting - accepts interpolation of xstr - handles nested interpolations when autocorrecting - accepts empty interpolation - accepts interpolation of irange where endpoints are not literals - handles backslash in double quotes when autocorrecting - behaves like literal interpolation - registers an offense for 1 in interpolation and removes interpolation around it - removes interpolation around 1 when there is more text - removes interpolation around multiple 1 - registers an offense only for final 1 in interpolation - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense for -1 in interpolation and removes interpolation around it - registers an offense only for final -1 in interpolation - removes interpolation around -1 when there is more text - removes interpolation around multiple -1 - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense only for final %w[v1 v2] in interpolation - registers an offense for %w[v1 v2] in interpolation and removes interpolation around it - removes interpolation around multiple %w[v1 v2] - removes interpolation around %w[v1 v2] when there is more text - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense for {"a" => "b"} in interpolation and removes interpolation around it - removes interpolation around multiple {"a" => "b"} - registers an offense only for final {"a" => "b"} in interpolation - removes interpolation around {"a" => "b"} when there is more text - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around 2.0 when there is more text - registers an offense for 2.0 in interpolation and removes interpolation around it - registers an offense only for final 2.0 in interpolation - removes interpolation around multiple 2.0 - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - in string-like contexts - removes interpolation in backticks - removes interpolation in regular expressions - removes interpolation in symbols - behaves like literal interpolation in words literal - removes interpolation of a symbol literal without space in %W[] - removes interpolation of an array containing a symbol literal without space in %W[] - accepts interpolation of a string literal with space in %W[] - accepts interpolation of an array literal containing a symbol with space in %W[] - accepts interpolation of a symbol literal with space in %W[] - removes interpolation of an array containing a string literal without space in %W[] - accepts interpolation of an array literal containing a string with space in %W[] - removes interpolation of a string literal without space in %W[] - behaves like non-special string literal interpolation - registers an offense for "foo" and removes the interpolation and quotes around "foo" - behaves like special keywords - accepts strings like __END__ - registers an offense and autocorrects interpolation after __END__ - behaves like literal interpolation - registers an offense only for final %i[s1 s2] in interpolation - registers an offense for %i[s1 s2] in interpolation and removes interpolation around it - removes interpolation around %i[s1 s2] when there is more text - removes interpolation around multiple %i[s1 s2] - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense for %w[v1] in interpolation and removes interpolation around it - registers an offense only for final %w[v1] in interpolation - removes interpolation around multiple %w[v1] - removes interpolation around %w[v1] when there is more text - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around multiple ["a", "b"] - registers an offense only for final ["a", "b"] in interpolation - registers an offense for ["a", "b"] in interpolation and removes interpolation around it - removes interpolation around ["a", "b"] when there is more text - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like special keywords - registers an offense and autocorrects interpolation after __ENCODING__ - accepts strings like __ENCODING__ - behaves like literal interpolation - removes interpolation around %w[] when there is more text - removes interpolation around multiple %w[] - registers an offense for %w[] in interpolation and removes interpolation around it - registers an offense only for final %w[] in interpolation - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around %i[s1 s2] when there is more text - removes interpolation around multiple %i[s1 s2] - registers an offense for %i[s1 s2] in interpolation and removes interpolation around it - registers an offense only for final %i[s1 s2] in interpolation - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation in words literal - accepts interpolation of an array literal containing a symbol with space in %I[] - removes interpolation of a symbol literal without space in %I[] - removes interpolation of an array containing a symbol literal without space in %I[] - accepts interpolation of a string literal with space in %I[] - accepts interpolation of an array literal containing a string with space in %I[] - accepts interpolation of a symbol literal with space in %I[] - removes interpolation of an array containing a string literal without space in %I[] - removes interpolation of a string literal without space in %I[] - behaves like literal interpolation - registers an offense for 0xaabb in interpolation and removes interpolation around it - removes interpolation around 0xaabb when there is more text - removes interpolation around multiple 0xaabb - registers an offense only for final 0xaabb in interpolation - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around multiple 0o377 - registers an offense only for final 0o377 in interpolation - removes interpolation around 0o377 when there is more text - registers an offense for 0o377 in interpolation and removes interpolation around it - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense for [] in interpolation and removes interpolation around it - removes interpolation around multiple [] - registers an offense only for final [] in interpolation - removes interpolation around [] when there is more text - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around nil when there is more text - removes interpolation around multiple nil - registers an offense only for final nil in interpolation - registers an offense for nil in interpolation and removes interpolation around it - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around multiple 123_456_789_123_456_789 - registers an offense for 123_456_789_123_456_789 in interpolation and removes interpolation around it - registers an offense only for final 123_456_789_123_456_789 in interpolation - removes interpolation around 123_456_789_123_456_789 when there is more text - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around true when there is more text - removes interpolation around multiple true - registers an offense for true in interpolation and removes interpolation around it - registers an offense only for final true in interpolation - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around 1_123 when there is more text - registers an offense for 1_123 in interpolation and removes interpolation around it - removes interpolation around multiple 1_123 - registers an offense only for final 1_123 in interpolation - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense for %I[s1 s2] in interpolation and removes interpolation around it - registers an offense only for final %I[s1 s2] in interpolation - removes interpolation around %I[s1 s2] when there is more text - removes interpolation around multiple %I[s1 s2] - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like non-special string literal interpolation - registers an offense for 'foo' and removes the interpolation and quotes around 'foo' - behaves like literal interpolation - registers an offense for 1..2 in interpolation and removes interpolation around it - removes interpolation around 1..2 when there is more text - removes interpolation around multiple 1..2 - registers an offense only for final 1..2 in interpolation - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like special keywords - accepts strings like __LINE__ - registers an offense and autocorrects interpolation after __LINE__ - behaves like literal interpolation - registers an offense only for final 1...2 in interpolation - registers an offense for 1...2 in interpolation and removes interpolation around it - removes interpolation around multiple 1...2 - removes interpolation around 1...2 when there is more text - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense only for final 1.2e-3 in interpolation - registers an offense for 1.2e-3 in interpolation and removes interpolation around it - removes interpolation around 1.2e-3 when there is more text - removes interpolation around multiple 1.2e-3 - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense only for final false in interpolation - registers an offense for false in interpolation and removes interpolation around it - removes interpolation around multiple false - removes interpolation around false when there is more text - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - removes interpolation around multiple :symbol - removes interpolation around :symbol when there is more text - registers an offense for :symbol in interpolation and removes interpolation around it - registers an offense only for final :symbol in interpolation - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense only for final %i[ s1 s2 ] in interpolation - removes interpolation around multiple %i[ s1 s2 ] - removes interpolation around %i[ s1 s2 ] when there is more text - registers an offense for %i[ s1 s2 ] in interpolation and removes interpolation around it - when there is non-literal and literal interpolation - when literal interpolation is before non-literal - only removes interpolation around literal - when literal interpolation is after non-literal - only removes interpolation around literal - behaves like literal interpolation - registers an offense only for final :"symbol" in interpolation - removes interpolation around :"symbol" when there is more text - registers an offense for :"symbol" in interpolation and removes interpolation around it - removes interpolation around multiple :"symbol" - when there is non-literal and literal interpolation - when literal interpolation is after non-literal - only removes interpolation around literal - when literal interpolation is before non-literal - only removes interpolation around literal - behaves like special keywords - accepts strings like __FILE__ - registers an offense and autocorrects interpolation after __FILE__ +RuboCop::Cop::Layout::EmptyLinesAroundBlockBody + when EnforcedStyle is empty_lines for do end block + ignores block with an empty body + is not fooled by single line blocks + registers an offense for block body not starting or ending with a blank + when EnforcedStyle is no_empty_lines for { } block + accepts block body starting with a line with spaces + registers an offense for block body ending with a blank + is not fooled by single line blocks + registers an offense for block body starting with a blank + registers an offense for block body starting with a blank passed to a multi-line method call + Ruby 2.7 + registers an offense for block body ending with a blank + when EnforcedStyle is no_empty_lines for do end block + registers an offense for block body ending with a blank + accepts block body starting with a line with spaces + is not fooled by single line blocks + registers an offense for block body starting with a blank passed to a multi-line method call + registers an offense for block body starting with a blank + Ruby 2.7 + registers an offense for block body ending with a blank + when EnforcedStyle is empty_lines for { } block + is not fooled by single line blocks + registers an offense for block body not starting or ending with a blank + ignores block with an empty body -RuboCop::Cop::Metrics::PerceivedComplexity - when Max is 2 - counts stupid nested if and else blocks - when AllowedMethods is enabled - does not register an offense when defining a class method - does not register an offense when defining an instance method - does not register an offense when using `define_method` - when AllowedPatterns is enabled - does not register an offense when defining an instance method - does not register an offense when defining a class method - does not register an offense when using `define_method` - when Max is 1 - registers an offense for a case/when block - registers an offense for a `define_method` - registers an offense for and - registers an offense for an unless modifier - registers an offense for || - accepts a method with no decision points - registers an offense for elsif and else blocks - registers an offense for a ternary operator - registers an offense for a for block - counts known iterating block - deals with nested if blocks containing && and || - counts else in a case with no argument - accepts complex code outside of methods - registers an offense for a case/when block without an expression after case - registers an offense for or - registers an offense for an until block - accepts an empty method - does not count unknown block calls - registers an offense for an if modifier - accepts an empty `define_method` - counts only a single method - registers an offense for a rescue block - registers an offense for a while block - registers an offense for && +RuboCop::Cop::Naming::BinaryOperatorParameterName + does not register an offense for arg named _other + does not register an offense for []= + registers an offense and corrects for `#+` when argument is not named other + does not register an offense for << + does not register an offense for the match operator + does not register an offense for multibyte character method name + works properly even if the argument not surrounded with braces + does not register an offense for arg named other + does not register an offense for non binary operators + registers an offense and corrects for `#equal?` when argument is not named other + does not register an offense for [] + registers an offense and corrects for `#eql?` when argument is not named other + registers an offense and corrects when assigned to argument in method body + does not register an offense for === + registers an offense and corrects when argument is referenced in method body -RuboCop::Cop::Style::EmptyLambdaParameter - does not crash on a super - registers an offense for an empty block parameter with a lambda - accepts a keyword lambda +RuboCop::Cop::Lint::DuplicateMagicComment + does not register an offense when encoding magic comments are not duplicated + registers an offense when different encoding magic comments are duplicated + registers an offense when same encoding magic comments are duplicated + registers an offense when frozen magic comments are duplicated + registers an offense when encoding and frozen magic comments are duplicated + does not register an offense when encoding and frozen magic comments are not duplicated + does not register an offense when frozen magic comments are not duplicated -RuboCop::Cop::InternalAffairs::SingleLineComparison - registers and corrects an offense when comparing `source_range.last_line` with `source_range.first_line` - registers and corrects an offense when comparing `source_range.first_line` with `source_range.last_line` - registers and corrects an offense when comparing `loc.last_line` with `loc.first_line` - registers and corrects an offense when comparing `last_line` with `first_line` - registers and corrects an offense when comparing `loc.first_line` with `loc.last_line` - does not register an offense when the receivers are not a match - registers and corrects an offense when negative comparing `last_line` with `first_line` - registers and corrects an offense when negative comparing `first_line` with `last_line` - registers and corrects an offense when comparing `loc.line` with `loc.last_line` - registers and corrects an offense when comparing `first_line` with `last_line` - does not register an offense when comparing the same line - registers and corrects an offense when comparing `loc.last_line` with `loc.line` +RuboCop::Cop::Style::StabbyLambdaParentheses + require_no_parentheses + registers an offense for a stabby lambda with parentheses + behaves like common + does not check the old lambda syntax + does not check a method call named lambda + does not check a stabby lambda without arguments + require_parentheses + does not register an offense for a stabby lambda with parentheses + registers an offense for a stabby lambda without parentheses + behaves like common + does not check a stabby lambda without arguments + does not check the old lambda syntax + does not check a method call named lambda -RuboCop::Cop::Style::RedundantRegexpCharacterClass - with a character class containing set intersection - does not register an offense - with a character class containing a negated posix bracket expression - does not register an offense - with a character class containing a single negated unicode character property - registers an offense and corrects - with a character class containing an interpolation - does not register an offense - with multiple character classes containing single characters - registers an offense and corrects - with a multi-line interpolation - ignores offenses in the interpolated expression - with a character class containing a space - when not using free-spaced mode - registers an offense and corrects - when using free-spaced mode - with a single space character class - does not register an offense with only /x - does not register an offense with /ix - does not register an offense with /iux - with a commented single-element character class - does not register an offense - with an unnecessary-character-class after a comment - registers an offense and corrects - with %r{} regexp - with a character class containing a single character before `+` quantifier - registers an offense and corrects - with multiple character classes containing single characters - registers an offense and corrects - with a character class containing a single character inside a group - registers an offense and corrects - with a character class containing a single character - registers an offense and corrects - with a character class containing a single character before `{n,m}` quantifier - registers an offense and corrects - with a character class containing multiple unicode code-points - does not register an offense and corrects - with a character class containing an escaped-b - does not register an offense - with a character class containing two characters - does not register an offense - with a character class containing a single unicode character property - registers an offense and corrects - with a character class containing escaped character requiring escape outside - registers an offense and corrects - with a regexp containing invalid g escape - registers an offense and corrects - with a character class containing a single unicode code-point - registers an offense and corrects - with a character class containing a single character inside a group - registers an offense and corrects - with escaped square brackets surrounding a single character - does not register an offense - with a character class containing a single character before `{n,m}` quantifier - registers an offense and corrects - with an interpolated unnecessary-character-class regexp - registers an offense and corrects - with a character class containing a negated-space meta-character - registers an offense and corrects - with a character class containing a space meta-character - registers an offense and corrects - with consecutive escaped square brackets inside a character class - does not register an offense - with a character class containing an unescaped-# - registers an offense and corrects - with a character class containing a single character - registers an offense and corrects - with a negated character class with a single element - does not register an offense - with a character class containing an escaped ] - registers an offense and corrects - with a character class containing an escaped [ - registers an offense and corrects - with a character class containing a single range - does not register an offense - with a character class containing an escaped-# - registers an offense and corrects - with a character class containing a character requiring escape outside - does not register an offense - with a character class containing an escaped-0 - does not register an offense - with consecutive escaped square brackets - does not register an offense - with a character class containing a posix bracket expression - does not register an offense - with an array index inside an interpolation - does not register an offense - with a redundant character class after an interpolation - registers an offense and corrects - with a character class with first element an escaped ] - does not register an offense - with a character class containing a single character before `+` quantifier - registers an offense and corrects +RuboCop::Cop::Layout::ParameterAlignment + aligned with fixed indentation + doesn't get confused by splat + accepts a method definition without parameters + accepts the first parameter being on a new row + accepts proper indentation + registers an offense and corrects parameters aligned to first param + accepts parameter lists on a single line + registers an offense and corrects parameters with double indent + defining self.method + accepts proper indentation + registers an offense and corrects parameters aligned to first param + aligned with first parameter + accepts the first parameter being on a new row + doesn't get confused by splat + accepts a method definition without parameters + registers an offense and corrects parameters with double indent + registers an offense and corrects parameters with single indent + accepts proper indentation + accepts parameter lists on a single line + registers an offense and corrects alignment in simple case + defining self.method + registers an offense and corrects parameters with single indent + accepts proper indentation -RuboCop::Cop::Lint::UnexpectedBlockArity - registers multiple offenses - with a block - when given no parameters +RuboCop::Cop::Lint::EmptyBlock + does not register an offense on an empty Proc.new + does not register an offense for empty block with inline comments + does not register an offense on an empty lambda + does not register an offense on an empty proc + does not register an offense on an empty ::Proc.new + does not register an offense when block is not empty + registers an offense for an empty block given to a non-Kernel `proc` method + registers an offense for empty block within method call + does not register an offense for empty block with inner comments + does not register an offense on an empty stabby lambda + when AllowComments is false + registers an offense for empty block with inner comments + registers an offense for empty block with inline comments + when AllowEmptyLambdas is false + registers an offense on an empty Proc.new + registers an offense for an empty lambda + registers an offense on an empty ::Proc.new + registers an offense for an empty stabby lambda + registers an offense on an empty proc + +RuboCop::Cop::Lint::EmptyEnsure + registers an offense and corrects empty ensure + does not register an offense for non-empty ensure + +RuboCop::Cop::VariableForce::Variable + .new + when non variable declaration node is passed + raises error + #referenced? + when the variable has an assignment + and the variable is referenced + is expected to be truthy + and the variable is not yet referenced + is expected to be falsey + when the variable is not assigned + is expected to be falsey + and the variable is referenced + is expected to be truthy + +RuboCop::Cop::Lint::EmptyConditionalBody + registers an offense for missing all branches of `if` and multiple `elsif` body + does not register an offense for missing `elsif` body with an inline comment + registers an offense for missing `if` and `else` body + registers an offense for missing second `elsif` body without an inline comment + autocorrects properly when the if is assigned to a variable + does not register an offense for missing `unless` body with a comment + registers an offense for missing `if` body with present `else` body + registers an offense for missing `if` body with `elsif` + registers an offense for missing `if` body + registers an offense for missing `unless` and `else` body + does not register an offense for missing `if` body with a comment + registers an offense for missing `if` and `elsif` body + registers an offense for missing `elsif` body + registers an offense for missing `unless` body + does not register an offense for missing `elsif` body with a comment + registers an offense for missing `if` body with `else` + registers an offense for missing `unless` body with `else` + registers an offense for missing all branches of `if` and `elsif` body + registers an offense for missing `elsif` body that is not the one with a comment + registers an offense for missing `if` and `else` body with some indentation + when AllowComments is false + registers an offense for missing `if` body with a comment + registers an offense for missing `elsif` body with a comment + registers an offense for missing `unless` body with a comment + +RuboCop::Cop::Lint::RandOne + behaves like offenses + Kernel.rand 1.0 registers an offense - with no receiver + behaves like offenses + Kernel.rand(1) + registers an offense + behaves like offenses + Kernel.rand(-1.0) + registers an offense + behaves like no offense + rand(2) does not register an offense - when destructuring - with arity 2 - does not register an offense - with arity 1 - registers an offense - with shadow args + behaves like offenses + rand(-1.0) registers an offense - with a keyword splat + behaves like no offense + Kernel.rand + does not register an offense + behaves like offenses + Kernel.rand(-1) registers an offense - with keyword args + behaves like no offense + rand + does not register an offense + behaves like offenses + rand 1 registers an offense - when given one parameter + behaves like no offense + ::Kernel.rand + does not register an offense + behaves like offenses + rand(-1) registers an offense - when given three parameters + behaves like offenses + ::Kernel.rand(1) + registers an offense + behaves like no offense + Kernel.rand(-1..1) does not register an offense - with optargs - with arity 2 - does not register an offense - with arity 1 - registers an offense - when given two parameters + behaves like no offense + Kernel.rand 2 does not register an offense - when given a splat parameter + behaves like offenses + rand(1.0) + registers an offense + behaves like no offense + rand(-1..1) does not register an offense - with a numblock - when given three parameters + +RuboCop::Cop::Style::UnlessLogicalOperators + EnforcedStyle is `forbid_logical_operators` + registers an offense when using only `or` + registers an offense when using `&&` followed by || + registers an offense when using only `&&` + does not register an offense when not using logical operator + does not register an offense when using if + registers an offense when using only `and` + registers an offense when using only `||` + does not register an offense when not used in unless + EnforcedStyle is `forbid_mixed_logical_operators` + registers an offense when using `||` and `or` + registers an offense when using `||` and `and` + registers an offense when using `&&` and `||` + does not register an offense when using only `and`s + does not register an offense when using `||` operator and invoked method name includes "or" in the conditional branch + does not register an offense when not used in unless + does not register an offense when not using logical operator + does not register an offense when using `&&` operator and invoked method name includes "and" in the conditional branch + registers an offense when using parentheses + does not register an offense when using only `||`s + does not register an offense when using if + does not register an offense when using only `or`s + does not register an offense when using only `&&`s + registers an offense when using `&&` and `or` + registers an offense when using `&&` and `and` + +RuboCop::Cop::Bundler::GemFilename + with EnforcedStyle set to `gems.rb` + with non-root gems.locked file path does not register an offense - with no receiver + with non-root Gemfile.lock file path + registers an offense + with non-root gems.rb file path does not register an offense - when given one parameter + with non-root Gemfile file path registers an offense - when given two parameters + with Gemfile.lock file path + registers an offense + with Gemfile file path + registers an offense + with gems.rb file path does not register an offense - when using enough parameters, but not all explicitly + with default configuration (EnforcedStyle => `Gemfile`) + with gems.rb file path + registers an offense + with Gemfile file path does not register an offense - when given no parameters + with non-root Gemfile file path + does not register an offense + with non-root Gemfile.lock file path + does not register an offense + with non-root gems.rb file path + registers an offense + with Gemfile.lock file path + does not register an offense + with gems.locked file path + registers an offense + with non-root gems.locked file path registers an offense -RuboCop::Cop::Style::RedundantFetchBlock - with SafeForConstants: false - does not register an offense when using `#fetch` with constant in the block - with SafeForConstants: true - registers an offense and corrects when using `#fetch` with Symbol in the block - does not register an offense when using `#fetch` with argument fallback - does not register an offense when using `#fetch` with String in the block and strings are not frozen - registers an offense and corrects when using `#fetch` with Complex in the block - registers an offense and corrects when using `#fetch` with Rational in the block - does not register an offense when using `#fetch` with an argument in the block - registers an offense and corrects when using `#fetch` with empty block - does not register an offense when using `#fetch` with interpolated Symbol in the block - registers an offense and corrects when using `#fetch` with Integer in the block - registers an offense and corrects when using `#fetch` with String in the block and strings are frozen - does not register an offense when using `#fetch` with `Rails.cache` - registers an offense and corrects when using `#fetch` with constant in the block - registers an offense and corrects when using `#fetch` with Float in the block - -RuboCop::Cop::Layout::BlockEndNewline - registers an offense and corrects when `}` of multiline block without processing is not on its own line - registers an offense and corrects when multiline block `}` is not on its own line and using multiple heredoc arguments - registers an offense and corrects when multiline block end is not on its own line - registers an offense and corrects when a multiline block ends with a hash - registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument - accepts a one-liner - registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument with method chain - accepts multiline blocks with newlines before the end - registers an offense and corrects when multiline block `}` is not on its own line and using multiple heredoc argument method chain - registers an offense and corrects when multiline block `}` is not on its own line and using method chain - registers an offense and corrects when multiline block `}` is not on its own line - registers an offense and corrects when a multiline block ends with a method call with hash arguments - Ruby 2.7 - registers an offense and corrects when multiline block `}` is not on its own line and using method chain - registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument - -RuboCop::Cop::Layout::ExtraSpacing - when ForceEqualSignAlignment is true - register offenses and correct complex nested assignments - does not register offenses for multiple complex nested assignments - does not register an offense if assignments are separated by blanks - register offenses and correct consecutive operator assignments which are not aligned - does not register an offense if assignments are aligned - registers an offense and corrects consecutive aref assignments which are not aligned - aligns the first assignment with the following assignment - register offenses and correct consecutive attribute assignments which are not aligned - does not register alignment errors on outdented lines - does not register an offense when optarg equals is not aligned with assignment equals sign - registers an offense and corrects consecutive assignments that are not aligned - when AllowForAlignment is true - accepts space between key and value in a hash with hash rockets - registers an offense and corrects alignment with token not preceded by space - registers an offense and corrects extra spacing in class inheritance - ignores trailing whitespace - ignores whitespace inside a string - ignores whitespace at the beginning of the line - registers an offense and corrects double extra spacing in variable assignment - registers an offense and corrects extra spacing before a unary plus in an argument list - accepts aligned values of an implicit hash literal - registers an offense and corrects extra space before a float - when spaces are present in a single-line hash literal - registers an offense and corrects hashes with hash rockets - registers an offense and corrects hashes with symbol keys - with extra spacing for alignment purposes - such as aligning tokens with empty line between - allows it - such as aligning trailing comments - allows it - such as aligning = on lines where there are trailing comments - allows it - such as aligning comments on non-adjacent lines - allows it - such as aligning with the same character - allows it - such as lining up assignments - allows it - such as lining up assignments with empty lines and comments in between - allows it - such as aligning long assignment expressions that include line breaks - allows it - such as lining up different kinds of assignments - allows it - when AllowBeforeTrailingComments is - false - does not trigger on only one space before comment - regsiters offense - true - allows it - doesn't interfere with AllowForAlignment - being false - such as aligning = on lines where there are trailing comments - registers offense(s) - such as aligning comments on non-adjacent lines - registers offense(s) - such as aligning trailing comments - does not register an offense - such as aligning long assignment expressions that include line breaks - registers offense(s) - such as lining up different kinds of assignments - registers offense(s) - such as lining up assignments with empty lines and comments in between - registers offense(s) - such as lining up assignments - registers offense(s) - such as aligning with the same character - registers offense(s) - such as aligning tokens with empty line between - does not register an offense - being true - such as aligning = on lines where there are trailing comments - allows it - such as lining up different kinds of assignments - allows it - such as lining up assignments with empty lines and comments in between - allows it - such as lining up assignments - allows it - such as aligning tokens with empty line between - allows it - such as aligning with the same character - allows it - such as aligning comments on non-adjacent lines - allows it - such as aligning trailing comments - allows it - such as aligning long assignment expressions that include line breaks - allows it - when AllowForAlignment is false - accepts space between key and value in a hash with hash rockets - registers an offense and corrects extra spacing before a unary plus in an argument list - accepts aligned values of an implicit hash literal - registers an offense and corrects alignment with token not preceded by space - registers an offense and corrects extra space before a float - ignores whitespace inside a string - ignores whitespace at the beginning of the line - ignores trailing whitespace - registers an offense and corrects double extra spacing in variable assignment - registers an offense and corrects extra spacing in class inheritance - when spaces are present in a single-line hash literal - registers an offense and corrects hashes with hash rockets - registers an offense and corrects hashes with symbol keys - with extra spacing for alignment purposes - such as lining up assignments - registers offense(s) - such as aligning = on lines where there are trailing comments - registers offense(s) - such as aligning tokens with empty line between - registers offense(s) - such as aligning with the same character - registers offense(s) - such as aligning trailing comments - registers offense(s) - such as lining up assignments with empty lines and comments in between - registers offense(s) - such as aligning comments on non-adjacent lines - registers offense(s) - such as lining up different kinds of assignments - registers offense(s) - such as aligning long assignment expressions that include line breaks - registers offense(s) - -RuboCop::Cop::Style::SlicingWithRange - <= Ruby 2.5 - reports no offense for array slicing with -1 - >= Ruby 2.7 - reports no offense for startless - >= Ruby 2.6 - reports an offense for slicing from expression to ..-1 - reports no offense for array with range inside - reports an offense for slicing to ..-1 - reports no offense for other methods - reports no offense for excluding end - -RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement - with no repeated character class elements - does not register an offense - with a repeated character class element inside a group - registers an offense and corrects - with a repeated character class element with interpolation - registers an offense and corrects - with a repeated character class element - registers an offense and corrects - with no repeated character class elements when `"\0\07"` (means `"\u0000\a"`) - does not register an offense - with a repeated range element - registers an offense and corrects - with a repeated character class element with quantifier - registers an offense and corrects - with a repeated character posix character class inside a group - registers an offense and corrects - with repeated character class elements when `"\0\08"` (means `"\u0000\u00008"`) - registers an offense - with repeated elements in different character classes - does not register an offense - with a repeated character class element and %r{} literal - registers an offense and corrects - with a repeated intersection character class - does not register an offense - with a range that covers a repeated element character class - does not register an offense - with multiple regexps with the same interpolation - does not register an offense +RuboCop::Cop::Layout::InitialIndentation + accepts empty file + accepts unindented comment + assignment + registers an offense for indented method definition + registers an offense and corrects indented assignment disregarding comment + accepts unindented method definition + for a file with byte order mark + registers an offense and corrects indented method call + registers an offense and corrects indented method call after comment + accepts unindented method call -RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis - correct cases - accepts method with heredoc argument of proc correct case - accepts double correct case - accepts when there is an argument between a heredoc argument and the closing paretheses - accepts hash correct case - accepts correct case with other param before - accepts double correct case nested - accepts method chain with heredoc argument correct case - accepts correct case with other param after - accepts simple correct case - accepts double correct case new line - invocation after the HEREDOC - ignores random call after - ignores random call - ignores tr - incorrect cases - simple incorrect case comma with spaces and comma in heredoc - detects - double case new line - detects and fixes - nested incorrect case - detects - simple incorrect case with call after - detects - complex incorrect case with multiple calls - detects and fixes the second - detects and fixes the first - simple incorrect case squiggles - detects - incorrect case in array with nested calls and double heredoc and spaced out comma - detects - complex chained incorrect case with multiple calls - detects and fixes the first - simple incorrect case comma with spaces - detects - incorrect case with other param before constructor - detects - simple incorrect case with call after trailing comma - detects - incorrect case with other param before - detects - double incorrect case - detects - incorrect case nested method call with comma - detects - incorrect case in array with double heredoc and spaced out comma - detects - simple incorrect case hash - detects - simple incorrect case - detects - incorrect case with other param before constructor and raise call - detects - incorrect case with other param after - detects - simple incorrect case comma - detects - incorrect case in array with spaced out comma - detects - double incorrect case new line chained calls - detects +RuboCop::Config + whether the cop is enabled + when an nested cop department is disabled + but an individual cop is enabled + the cop setting overrides the department + and an individual cop is not specified + the cop setting overrides the department + when a cop has configuration but no explicit Enabled setting + enables the cop by default + when an entire cop department is disabled + but an individual cop is enabled + the cop setting overrides the department + when configuration has no mention of a cop + enables the cop that is not mentioned + when all cops are explicitly enabled by default + enables the cop that is not mentioned + when all cops are disabled by default + disables the cop that is not mentioned + when an entire cop department is enabled + but an individual cop is disabled + still disables the cop + #patterns_to_exclude + when config file has AllCops => Exclude key + returns the Exclude value + #for_department + always returns the department's config + accepts a Symbol + #possibly_include_hidden? + returns true when Include config includes a regex + returns true when Include config includes a toplevel dotfile + returns true when Include config only includes regular paths + returns true when Include config includes a dotfile in a path + #validate + when the configuration includes any common parameter + does not raise validation error + when the configuration includes multiple valid enforced styles + does not raise validation error + when the configuration includes multiple invalid enforced styles + raises validation error + when the configuration includes an obsolete cop + raises validation error + when the configuration includes an empty section + raises validation error + when the configuration includes a valid EnforcedStyle + does not raise validation error + when the configuration includes Lint/Syntax cop + when the configuration does not match the default + raises validation error + when the configuration matches the default + does not raise validation error + when the configuration includes an obsolete parameter + raises validation error + when the configuration includes any unrecognized cop name + raises an validation error + conflicting Safe settings + when the configuration includes an unsafe cop that is explicitly declared to have a safe autocorrection + raises validation error + when the configuration includes an unsafe cop without a declaration of its autocorrection + does not raise validation error + when the configuration includes the obsolete Style/IfUnlessModifier: MaxLineLength parameter + raises validation error + when the configuration includes any unrecognized parameter + prints a warning message + when the configuration is in the base RuboCop config folder + is not validated + when the configuration includes obsolete parameters and cops + raises validation error + when the configuration includes an obsolete EnforcedStyle parameter + raises validation error + when the configuration includes a valid enforced style + does not raise validation error + when the configuration includes any unrecognized cop name and given `--ignore-unrecognized-cops` option + there are no unrecognized cops + does not print any warnings + there is unrecognized cop + prints a warning about the cop + when the configuration includes multiple but config does not allow + raises validation error + when the configuration includes an invalid enforced style + raises validation error + when the configuration includes an invalid EnforcedStyle + raises validation error + when the empty section is AllCops + raises validation error + when all cops are both Enabled and Disabled by default + raises validation error + when the configuration includes multiple valid enforced styles and one invalid style + raises validation error + when the configuration includes the obsolete Style/WhileUntilModifier: MaxLineLength parameter + raises validation error + #deprecation_check + when there is AllCops configuration + if there are is an Excludes key + yields + if there are no Excludes or Includes keys + does not yield + if there are is an Includes key + yields + when there is no AllCops configuration + does not yield + #file_to_exclude? + when the passed path does not match any of patterns to exclude + returns false + when the passed path matches any of patterns to exclude + returns true + #make_excludes_absolute + when config is in subdirectory + generates valid absolute directory + when config is in root directory + generates valid absolute directory + #allowed_camel_case_file? + when the passed path matches allowed camel case patterns to include + is expected to equal true + when the passed path does not match allowed camel case patterns to include + is expected to equal false + when the passed path is a gemspec + is expected to equal true + #patterns_to_include + when config file has AllCops => Include key + returns the Include value + #file_to_include? + when the passed path does not match any of patterns to include + returns false + when the passed path matches any of patterns to include + returns true + #for_badge + works if department has no config + takes into account the department + #check + when a deprecated configuration is detected + prints a warning message for the loaded path -RuboCop::Cop::Lint::RaiseException - registers an offense and corrects for `fail` with `Exception` - registers an offense and corrects for `raise` with `Exception.new` and message - registers an offense and corrects for `raise` with `Exception` and message - does not register an offense when raising Exception with explicit namespace - registers an offense and corrects for `raise` with `Exception` - registers an offense and corrects for `raise` with `::Exception` - does not register an offense for `raise` without arguments - registers an offense and corrects for `fail` with `Exception.new` and message - registers an offense and corrects for `raise` with `::Exception.new` - registers an offense and corrects for `raise` with `::Exception` and message - registers an offense and corrects for `fail` with `Exception` and message - does not register an offense for `fail` without arguments - registers an offense and corrects for `raise` with `Exception.new(args*)` - when under namespace - does not register an offense when Exception without cbase specified - registers an offense and corrects when Exception with cbase specified +RuboCop::MagicComment + returns nil for shareable_constant_value when comment is # typed: false + returns nil for shareable_constant_value when comment is # vim: filetype=python, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # ENCODING: utf-8 + returns nil for typed when comment is # -*- encoding : ascii-8bit -*- + returns nil for encoding when comment is # vim:fileencoding=utf-8 + returns nil for frozen_string_literal when comment is # coding: utf-8 + returns nil for typed when comment is # frozen-string-literal: true + returns nil for shareable_constant_value when comment is # vim: filetype=ruby,fileencoding=ascii-8bit + returns true for frozen_string_literal when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns "ascii-8bit" for encoding when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict + returns "literal" for shareable_constant_value when comment is # SHAREABLE-CONSTANT-VALUE: literal + returns nil for encoding when comment is # xyz shareable_constant_value: literal xyz + returns nil for shareable_constant_value when comment is # fRoZeN-sTrInG_lItErAl: true + returns nil for typed when comment is # coding: utf-8 + returns nil for encoding when comment is # typed: true + returns nil for encoding when comment is # + returns false for frozen_string_literal when comment is # frozen_string_literal: false + returns nil for encoding when comment is # -*- frozen-string-literal: true -*- + returns nil for typed when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict + returns nil for encoding when comment is # typed: strong + returns true for frozen_string_literal when comment is # frozen_string_literal:true + returns nil for shareable_constant_value when comment is # encoding: ascii-8bit frozen_string_literal: true + returns nil for typed when comment is # shareable_constant_value: literal + returns nil for encoding when comment is # shareable_constant_value: none + returns nil for shareable_constant_value when comment is # -*- coding: ASCII-8BIT; typed: strict -*- + returns nil for encoding when comment is # @typed + returns nil for frozen_string_literal when comment is # eNcOdInG: utf-8 + returns "ascii-8bit" for encoding when comment is # -*- coding: ASCII-8BIT; typed: strict -*- + returns nil for shareable_constant_value when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns nil for typed when comment is # vim: filetype=python, fileencoding=ascii-8bit + returns true for frozen_string_literal when comment is # frozen_string_literal: true + returns "ascii-8bit" for encoding when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns nil for frozen_string_literal when comment is # xyz shareable_constant_value: literal + returns "ascii-8bit" for encoding when comment is # encoding: ascii-8bit frozen_string_literal: true + returns nil for frozen_string_literal when comment is # shareable_constant_value: experimental_copy + returns nil for shareable_constant_value when comment is # typed: true + returns nil for frozen_string_literal when comment is # typed: false + returns nil for frozen_string_literal when comment is # + returns nil for typed when comment is # + returns nil for shareable_constant_value when comment is # xyz shareable_constant_value: literal + returns nil for frozen_string_literal when comment is #vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # vim: filetype=ruby,fileencoding=ascii-8bit + returns true for frozen_string_literal when comment is # -*- frozen-string-literal: true -*- + returns nil for typed when comment is # xyz shareable_constant_value: literal xyz + returns nil for typed when comment is # encoding: ascii-8bit frozen_string_literal: true + returns "strict" for typed when comment is #typed:strict + returns nil for shareable_constant_value when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # shareable-constant-value: literal + returns nil for frozen_string_literal when comment is # typed:strict + returns nil for typed when comment is # -*- coding: ASCII-8BIT; typed: strict -*- + returns nil for typed when comment is # vim: filetype=ruby,fileencoding=ascii-8bit + returns nil for typed when comment is # FROZEN-STRING-LITERAL: true + returns nil for shareable_constant_value when comment is # frozen_string_literal: invalid + returns nil for frozen_string_literal when comment is # coding: utf-8 + returns nil for encoding when comment is # typed:strict + returns nil for typed when comment is # vim:fileencoding=utf-8 + returns nil for shareable_constant_value when comment is # frozen_string_literal: false + returns nil for shareable_constant_value when comment is # FROZEN-STRING-LITERAL: true + returns nil for frozen_string_literal when comment is # vim:fileencoding=utf-8 + returns nil for encoding when comment is # frozen_string_literal: false + returns nil for encoding when comment is # FROZEN-STRING-LITERAL: true + returns nil for shareable_constant_value when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns true for frozen_string_literal when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns nil for shareable_constant_value when comment is #typed:strict + returns "utf-8" for encoding when comment is # coding: utf-8 + returns nil for encoding when comment is # shareable_constant_value: literal + returns nil for frozen_string_literal when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| + returns nil for typed when comment is # shareable_constant_value: experimental_everything + returns nil for shareable_constant_value when comment is # typed:strict + returns true for frozen_string_literal when comment is # frozen-string-literal: true + returns "utf-8" for encoding when comment is # encoding: utf-8 + returns nil for encoding when comment is # fRoZeN-sTrInG_lItErAl: true + returns nil for frozen_string_literal when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns "experimental_copy" for shareable_constant_value when comment is # shareable_constant_value: experimental_copy + returns nil for frozen_string_literal when comment is # -*- encoding : ascii-8bit -*- + returns nil for frozen_string_literal when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for encoding when comment is # typed: strict + returns nil for typed when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns nil for shareable_constant_value when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for typed when comment is # coding: utf-8 + returns true for frozen_string_literal when comment is # frozen_string_literal: true + returns nil for typed when comment is # -*- frozen-string-literal: true -*- + returns nil for encoding when comment is #typed:strict + returns nil for shareable_constant_value when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict + returns nil for encoding when comment is # sHaReaBLE-CoNstANT-ValUE: literal + returns nil for frozen_string_literal when comment is # typed: strict + returns "utf-8" for encoding when comment is # coding: utf-8 + returns nil for typed when comment is # frozen_string_literal: invalid + returns nil for frozen_string_literal when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for shareable_constant_value when comment is # typed: strict + returns nil for frozen_string_literal when comment is # shareable_constant_value: literal + returns "ascii-8bit" for encoding when comment is # -*- encoding : ascii-8bit -*- + returns nil for typed when comment is # shareable_constant_value:literal + returns nil for shareable_constant_value when comment is # frozen_string_literal: true + returns nil for encoding when comment is # typed: ignore + returns nil for typed when comment is # shareable_constant_value: experimental_copy + returns nil for shareable_constant_value when comment is # incoding: utf-8 + returns nil for shareable_constant_value when comment is # coding: utf-8 + returns nil for encoding when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| + returns nil for typed when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for shareable_constant_value when comment is # eNcOdInG: utf-8 + returns nil for frozen_string_literal when comment is # typed: true + returns "ascii-8bit" for encoding when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for typed when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # sHaReaBLE-CoNstANT-ValUE: literal + returns nil for shareable_constant_value when comment is # frozen-string-literal: true + returns nil for encoding when comment is # incoding: utf-8 + returns nil for shareable_constant_value when comment is # frozen_string_literal: true encoding: ascii-8bit + returns nil for shareable_constant_value when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| + returns "invalid" for frozen_string_literal when comment is # frozen_string_literal: invalid + returns nil for encoding when comment is # shareable-constant-value: literal + returns nil for shareable_constant_value when comment is # frozen_string_literal:true + returns nil for frozen_string_literal when comment is # -*- coding: ASCII-8BIT; typed: strict -*- + returns nil for frozen_string_literal when comment is # typed: strong + returns nil for encoding when comment is # shareable_constant_value:literal + returns nil for encoding when comment is # frozen_string_literal:true + returns "ascii-8bit" for encoding when comment is # frozen_string_literal: true encoding: ascii-8bit + returns nil for encoding when comment is # frozen_string_literal: true + returns "strict" for typed when comment is # typed:strict + returns nil for shareable_constant_value when comment is # typed: strong + returns nil for typed when comment is # frozen_string_literal: true + returns nil for frozen_string_literal when comment is # encoding: ascii-8bit frozen_string_literal: true + returns nil for shareable_constant_value when comment is # ENCODING: utf-8 + returns nil for typed when comment is # xyz shareable_constant_value: literal + returns nil for encoding when comment is # frozen_string_literal: true + returns "ascii-8bit" for encoding when comment is # vim: filetype=python, fileencoding=ascii-8bit + returns nil for typed when comment is # ENCODING: utf-8 + returns nil for shareable_constant_value when comment is # -*- encoding : ascii-8bit -*- + returns nil for typed when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns "true" for typed when comment is # typed: true + returns "literal" for shareable_constant_value when comment is # shareable_constant_value:literal + returns nil for frozen_string_literal when comment is # shareable_constant_value: experimental_everything + returns "ascii-8bit" for encoding when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for shareable_constant_value when comment is # vim:fileencoding=utf-8 + returns nil for typed when comment is # frozen_string_literal: false + returns nil for frozen_string_literal when comment is # typed: ignore + returns nil for typed when comment is # encoding: utf-8 + returns "literal" for shareable_constant_value when comment is # sHaReaBLE-CoNstANT-ValUE: literal + returns "none" for shareable_constant_value when comment is # shareable_constant_value: none + returns "false" for typed when comment is # typed: false + returns nil for shareable_constant_value when comment is # encoding: stateless-iso-2022-jp-kddi + returns nil for typed when comment is # encoding: stateless-iso-2022-jp-kddi + returns "literal" for shareable_constant_value when comment is # shareable_constant_value: literal + returns "stateless-iso-2022-jp-kddi" for encoding when comment is # encoding: stateless-iso-2022-jp-kddi + returns nil for typed when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| + returns nil for frozen_string_literal when comment is # xyz shareable_constant_value: literal xyz + returns nil for typed when comment is # @typed + returns "ignore" for typed when comment is # typed: ignore + returns nil for typed when comment is # shareable_constant_value: none + returns nil for frozen_string_literal when comment is # frozen_string_literal: true encoding: ascii-8bit + returns nil for typed when comment is #vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for typed when comment is # incoding: utf-8 + returns nil for typed when comment is # frozen_string_literal: true + returns nil for encoding when comment is # shareable_constant_value: experimental_everything + returns nil for typed when comment is # frozen_string_literal: true encoding: ascii-8bit + returns "ascii-8bit" for encoding when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- + returns nil for shareable_constant_value when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for shareable_constant_value when comment is #vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # incoding: utf-8 + returns nil for typed when comment is # sHaReaBLE-CoNstANT-ValUE: literal + returns nil for frozen_string_literal when comment is #typed:strict + returns nil for frozen_string_literal when comment is # shareable_constant_value:literal + returns nil for encoding when comment is # frozen_string_literal: invalid + returns nil for frozen_string_literal when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict + returns nil for frozen_string_literal when comment is # shareable_constant_value: none + returns nil for typed when comment is # fRoZeN-sTrInG_lItErAl: true + returns nil for encoding when comment is # vim: filetype=ruby,fileencoding=ascii-8bit + returns nil for typed when comment is # eNcOdInG: utf-8 + returns nil for typed when comment is # shareable-constant-value: literal + returns nil for shareable_constant_value when comment is # coding: utf-8 + returns nil for encoding when comment is # SHAREABLE-CONSTANT-VALUE: literal + returns nil for shareable_constant_value when comment is # + returns nil for frozen_string_literal when comment is # encoding: stateless-iso-2022-jp-kddi + returns nil for frozen_string_literal when comment is # SHAREABLE-CONSTANT-VALUE: literal + returns "strong" for typed when comment is # typed: strong + returns "literal" for shareable_constant_value when comment is # shareable-constant-value: literal + returns "strict" for typed when comment is # typed: strict + returns nil for typed when comment is # SHAREABLE-CONSTANT-VALUE: literal + returns nil for shareable_constant_value when comment is # typed: ignore + returns "ascii-8bit" for encoding when comment is #vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for frozen_string_literal when comment is # vim: filetype=python, fileencoding=ascii-8bit + returns "utf-8" for encoding when comment is # ENCODING: utf-8 + returns true for frozen_string_literal when comment is # FROZEN-STRING-LITERAL: true + returns nil for encoding when comment is # shareable_constant_value: experimental_copy + returns nil for frozen_string_literal when comment is # encoding: utf-8 + returns "experimental_everything" for shareable_constant_value when comment is # shareable_constant_value: experimental_everything + returns nil for shareable_constant_value when comment is # @typed + returns nil for shareable_constant_value when comment is # frozen_string_literal: true + returns nil for shareable_constant_value when comment is # -*- frozen-string-literal: true -*- + returns true for frozen_string_literal when comment is # fRoZeN-sTrInG_lItErAl: true + returns "utf-8" for encoding when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for encoding when comment is # frozen-string-literal: true + returns nil for shareable_constant_value when comment is # xyz shareable_constant_value: literal xyz + returns nil for encoding when comment is # xyz shareable_constant_value: literal + returns "utf-8" for encoding when comment is # eNcOdInG: utf-8 + returns nil for encoding when comment is # typed: false + returns nil for shareable_constant_value when comment is # encoding: utf-8 + returns nil for frozen_string_literal when comment is # @typed + returns nil for typed when comment is # vim: filetype=ruby, fileencoding=ascii-8bit + returns nil for typed when comment is # frozen_string_literal:true + #valid? + with an empty string + is expected to equal false + with an shareable constant value comment + is expected to equal true + with a non magic comment + is expected to equal false + with an encoding comment + is expected to equal true + with an frozen string literal comment + is expected to equal true + #valid_shareable_constant_value? + when given comment specified as unknown value + is expected to equal false + when given comment specified as `literal` + is expected to equal true + when given comment specified as `none` + is expected to equal true + when given comment is not specified + is expected to equal false + when given comment specified as `experimental_everything` + is expected to equal true + when given comment specified as `experimental_copy` + is expected to equal true + #without + emacs format + with multiple tokens + is expected to eq "# -*- frozen_string_literal: true -*-" + with one token + is expected to eq "" + simple format + when the entire comment is a single value + is expected to eq "" + when the comment contains a different magic value + is expected to eq "# frozen-string-literal: true" + vim format + when the comment has multiple tokens + is expected to eq "# vim: filetype=ruby" -RuboCop::Cop::Style::ExpandPathArguments - registers an offense when using `File.expand_path('../../lib', __FILE__)` - does not register an offense when using `File.expand_path('..', __dir__)` - does not register an offense when using `File.expand_path(__FILE__)` - registers an offense when using `::File.expand_path('./../..', __FILE__)` - does not register an offense when using `File.expand_path(path, __FILE__)` - registers an offense when using `Pathname.new(__FILE__).parent.expand_path` - registers an offense when using `File.expand_path('..', __FILE__)` - registers an offense when using `File.expand_path('./../..', __FILE__)` - registers an offense when using `File.expand_path('.', __FILE__)` - registers an offense when using `File.expand_path('../..', __FILE__)` - does not register an offense when using `File.expand_path(__dir__)` - registers an offense when using `Pathname(__FILE__).parent.expand_path` - does not register an offense when using `Pathname(__dir__).expand_path` - registers an offense when using `File.expand_path('../../..', __FILE__)` - does not register an offense when using `File.expand_path("#{path_to_file}.png", __FILE__)` - registers an offense when using `::Pathname.new(__FILE__).parent.expand_path` +RuboCop::Cop::Lint::EnsureReturn + registers an offense when returning multiple values in `ensure` + registers an offense and corrects for return with argument in ensure + does not register an offense for return outside ensure + does not check when ensure block has no body + registers an offense and corrects for return in ensure RuboCop::Cop::VariableForce::VariableTable - #find_variable with an empty scope stack - returns nil + #declare_variable + adds variable to current scope with its name as key + returns the added variable + #pop_scope + returns popped scope object + #push_scope + returns pushed scope object #find_variable when current scope is not block when a variable with the target name does not exist in current scope @@ -14029,24 +11117,18 @@ and does not exist in all outer scopes returns nil but exists in a indirect outer scope - when the direct outer scope is block - returns the indirect outer scope variable when the direct outer scope is not block returns nil + when the direct outer scope is block + returns the indirect outer scope variable when a variable with the target name exists in current scope - and also exists in outer scope - returns the current scope variable and does not exist in outer scope returns the current scope variable - #push_scope - returns pushed scope object - #current_scope_level - increases by pushing scope - decreases by popping scope - #declare_variable - adds variable to current scope with its name as key - returns the added variable + and also exists in outer scope + returns the current scope variable #accessible_variables + when there are no variables + returns empty array when the direct outer scope has some variables and the current scope is not block returns only the current scope variables @@ -14054,1501 +11136,530 @@ returns the current and direct outer scope variables when the current scope has some variables returns all the variables - when there are no variables - returns empty array - #pop_scope - returns popped scope object - -RuboCop::Cop::Style::RedundantCapitalW - registers no offense for %w with interpolation-like syntax - registers no offense for %w without interpolation - registers no offense for arrays with character constants - does not register an offense for array with one element - does not register an offense for array containing non-string - does not register an offense for array with empty strings - registers no offense for %W with interpolation - registers an offense for misused %W with different bracket - registers no offense for normal arrays of strings - does not register an offense for array of non-words - registers an offense for misused %W - registers no offense for %W with special characters - registers no offense for normal arrays of strings with interpolation + #current_scope_level + increases by pushing scope + decreases by popping scope + #find_variable with an empty scope stack + returns nil -RuboCop::CLI --disable-uncorrectable - --disable-uncorrectable - does not disable anything for cops that support autocorrect - when exist offense for Layout/SpaceInsideArrayLiteralBrackets - when `EnforcedStyle: no_space` - does not disable anything for cops that support autocorrect - when `EnforcedStyle: space` - does not disable anything for cops that support autocorrect - if a one-line disable statement doesn't fit - adds before-and-after disable statement - and the offense is inside a heredoc - adds before-and-after disable statement around the heredoc - if one one-line disable statement fits - adds it when the cop supports autocorrect but does not correct the offense - adds it - and there are two offenses of the same kind on one line - adds a single one-line disable statement - but there are more offenses on the line and they don't all fit - adds both one-line and before-and-after disable statements +RuboCop::Cop::Style::InverseMethods + registers an offense for calling !.none? with a symbol proc + registers an offense for not (foo == bar) + registers an offense for !(foo != bar) + registers an offense for !foo.even? + registers an offense for !(foo < bar) + registers an offense for !foo.include? + registers an offense for not (foo != bar) + registers an offense for !foo.blank? + registers an offense for !(foo !~ bar) + registers an offense for not (foo < bar) + allows comparing camel case constants on the right + allows an inverse method when double negation is used + registers an offense for not (foo =~ bar) + registers an offense for !(foo > bar) + registers an offense for comparing snake case constants on the left + registers an offense for !foo.exclude? + registers an offense for !foo.any? + registers an offense for not (foo !~ bar) + allows an inverse method in a block with next + registers an offense for !foo.present? + allows comparing camel case constants on the left + allows a method call without a not + allows an inverse method with a block when double negation is used + registers an offense for !(foo == bar) + registers an offense for comparing snake case constants on the right + registers an offense for !(foo =~ bar) + registers an offense for calling !.any? inside parens + registers an offense for not (foo > bar) + registers an offense for !foo.none? + registers an offense for calling !.none? with a block + registers an offense for !foo.odd? + Ruby 2.7 + registers an offense for calling !.none? with a numblock + behaves like all variable types + registers an offense for calling !FOO::BAR.none? + registers an offense for calling not FOO::BAR.none? + behaves like all variable types + registers an offense for calling not FOO.none? + registers an offense for calling !FOO.none? + behaves like all variable types + registers an offense for calling not foo["bar"].none? + registers an offense for calling !foo["bar"].none? + behaves like all variable types + registers an offense for calling !foo.none? + registers an offense for calling not foo.none? + behaves like all variable types + registers an offense for calling !$foo.none? + registers an offense for calling not $foo.none? + behaves like all variable types + registers an offense for calling not @@foo.none? + registers an offense for calling !@@foo.none? + inverse blocks + corrects an inverted method call when using `BasicObject#!` with spaces before the method call + corrects an inverted method call when using `BasicObject#!` + registers an offense for foo.reject! { |e| !e } + registers an offense for an inverted equality block + registers a single offense for nested inverse method calls + registers an offense for a multiline method call where the last method is inverted + corrects an inverted method call when using `BasicObject#!` with spaces before the method call + registers an offense for an inverted equality block + registers an offense for foo.select! { |e| !e } + registers an offense for foo.select { |e| !e } + corrects an inverted do end method call + corrects an inverted method call when using `BasicObject#!` + corrects an inverted method call when using `BasicObject#!` + registers an offense for foo.reject { |e| !e } + registers a single offense for nested inverse method calls + corrects an inverted method call when using `BasicObject#!` with spaces before the method call + registers an offense for a multiline inverted equality block + registers an offense for a multiline method call where the last method is inverted + registers an offense for a multiline method call where the last method is inverted + corrects an inverted method call + corrects an inverted method call when using `BasicObject#!` with spaces before the method call + registers an offense for an inverted equality block + registers an offense for a multiline method call where the last method is inverted + corrects an inverted do end method call + registers a single offense for nested inverse method calls + corrects an inverted do end method call + corrects an inverted method call when using `BasicObject#!` + corrects an inverted method call + corrects an inverted do end method call + registers an offense for a multiline inverted equality block + registers an offense for a multiline inverted equality block + registers a single offense for nested inverse method calls + corrects an inverted method call + corrects a complex inverted method call + corrects a complex inverted method call + corrects an inverted method call + registers an offense for an inverted equality block + corrects a complex inverted method call + registers an offense for a multiline inverted equality block + corrects a complex inverted method call + behaves like all variable types + registers an offense for calling not @foo.none? + registers an offense for calling !@foo.none? + behaves like all variable types + registers an offense for calling !foo.bar.none? + registers an offense for calling not foo.bar.none? -RuboCop::Cop::Style::MultilineIfModifier - unless guard clause - allows a one liner - registers an offense when indented - allows a multiline condition - registers an offense - if guard clause - allows a one liner - allows a multiline condition - registers an offense - registers an offense when indented +RuboCop::Cop::Style::RedundantConditional + does not register an offense for if/else with non-boolean results + registers an offense for ternary with negated boolean results + allows ternary with non-boolean results + registers an offense for if/elsif/else with boolean results + registers an offense for ternary with boolean results + registers an offense for if/else with negated boolean results + does not register an offense for if/elsif/else with non-boolean results + registers an offense for if/else with boolean results + registers an offense for if/elsif/else with negated boolean results -RuboCop::Cop::Style::NegatedWhile - does not blow up for empty until condition - accepts a while where only part of the condition is negated - registers an offense for while with exclamation point condition - registers an offense for until with exclamation point condition - autocorrects by replacing while not with until - accepts a while where the condition is doubly negated - registers an offense for while with "not" condition - autocorrects by replacing until not with while - does not blow up for empty while condition +RuboCop::Cop::Style::SelectByRegexp + with reject + does not register an offense when the block arity is not 1 + registers an offense and corrects when the receiver is an array + does not register an offense when given a proc + registers an offense and corrects for `blockvar =~ regexp` + registers an offense if `to_h` is in the receiver chain but not the actual receiver + does not register an offense when the receiver is `to_hash` + registers an offense and corrects without a receiver + does not register an offense when the block does not match a regexp + registers an offense and corrects for `blockvar =~ lvar` + registers an offense and corrects for `match?` + registers an offense and corrects with a multiline block + does not register an offense when the receiver is a hash literal + does not register an offense when the block uses an external variable in a regexp match + registers an offense and corrects when the receiver is a set + does not register an offense when the block param is a method argument + registers an offense and corrects for `regexp =~ blockvar` + does not register an offense when the block has multiple expressions + registers an offense and corrects when there is no explicit regexp + registers an offense and corrects for `Regexp#match?` + registers an offense and corrects when the receiver is a range + does not register an offense when the receiver is `Hash.new` + does not register an offense when the receiver is `Hash[]` + registers an offense and corrects for `lvar =~ blockvar` + does not register an offense when the receiver is `to_h` + does not register an offense when the receiver is `ENV` + does not register an offense when there is no block + with `numblock`s + registers an offense and corrects for `match?` + does not register an offense when using `match?` without a receiver + does not register an offense when the param is a method argument + registers an offense and corrects for `regexp =~ blockvar` + registers an offense and corrects for `Regexp#match?` + does not register an offense if there is more than one numbered param + registers an offense and corrects for `blockvar =~ regexp` + with select + registers an offense and corrects for `lvar =~ blockvar` + does not register an offense when the receiver is `ENV` + does not register an offense when the block does not match a regexp + does not register an offense when the receiver is `to_h` + does not register an offense when the receiver is `Hash.new` + registers an offense if `to_h` is in the receiver chain but not the actual receiver + does not register an offense when the receiver is a hash literal + registers an offense and corrects for `blockvar =~ regexp` + does not register an offense when the receiver is `to_hash` + does not register an offense when the block param is a method argument + registers an offense and corrects when there is no explicit regexp + does not register an offense when the block arity is not 1 + does not register an offense when the block uses an external variable in a regexp match + registers an offense and corrects for `Regexp#match?` + registers an offense and corrects for `regexp =~ blockvar` + registers an offense and corrects when the receiver is a range + registers an offense and corrects when the receiver is a set + does not register an offense when given a proc + registers an offense and corrects without a receiver + does not register an offense when the block has multiple expressions + registers an offense and corrects when the receiver is an array + does not register an offense when there is no block + registers an offense and corrects for `blockvar =~ lvar` + registers an offense and corrects with a multiline block + registers an offense and corrects for `match?` + does not register an offense when the receiver is `Hash[]` + with `numblock`s + does not register an offense if there is more than one numbered param + registers an offense and corrects for `blockvar =~ regexp` + registers an offense and corrects for `regexp =~ blockvar` + registers an offense and corrects for `match?` + does not register an offense when using `match?` without a receiver + does not register an offense when the param is a method argument + registers an offense and corrects for `Regexp#match?` + with find_all + does not register an offense when given a proc + registers an offense and corrects when the receiver is a set + does not register an offense when the block uses an external variable in a regexp match + does not register an offense when the receiver is `ENV` + does not register an offense when the block arity is not 1 + does not register an offense when the receiver is `to_hash` + does not register an offense when the block param is a method argument + registers an offense and corrects when there is no explicit regexp + registers an offense if `to_h` is in the receiver chain but not the actual receiver + does not register an offense when the receiver is `Hash.new` + registers an offense and corrects for `match?` + registers an offense and corrects for `Regexp#match?` + registers an offense and corrects when the receiver is an array + registers an offense and corrects for `lvar =~ blockvar` + registers an offense and corrects without a receiver + registers an offense and corrects for `blockvar =~ lvar` + does not register an offense when the block has multiple expressions + does not register an offense when the block does not match a regexp + registers an offense and corrects when the receiver is a range + does not register an offense when there is no block + registers an offense and corrects with a multiline block + does not register an offense when the receiver is `Hash[]` + does not register an offense when the receiver is a hash literal + does not register an offense when the receiver is `to_h` + registers an offense and corrects for `blockvar =~ regexp` + registers an offense and corrects for `regexp =~ blockvar` + with `numblock`s + registers an offense and corrects for `blockvar =~ regexp` + does not register an offense when the param is a method argument + registers an offense and corrects for `Regexp#match?` + does not register an offense if there is more than one numbered param + registers an offense and corrects for `match?` + does not register an offense when using `match?` without a receiver + registers an offense and corrects for `regexp =~ blockvar` -RuboCop::Cop::Layout::SpaceBeforeComma - registers an offense and corrects method call arg with space before comma - does not register an offense for no spaces before comma - handles more than one space before a comma - registers an offense and corrects block argument with space before comma - registers an offense and corrects array index with space before comma - heredocs - registers an offense and corrects +RuboCop::Cop::Style::PreferredHashMethods + with enforced `verbose` style + accepts value? with no args + registers an offense for value? with one arg + accepts key? with no args + registers an offense for key? with one arg + with enforced `short` style + registers an offense for has_key? with one arg + accepts has_key? with no args + registers an offense for has_value? with one arg + accepts has_value? with no args + when using safe navigation operator + registers an offense for has_value? with one arg -RuboCop::Formatter::Colorizable - #white - invokes #colorize(string, white - #black - invokes #colorize(string, black - #colorize - when the global Rainbow.enabled is true - and the formatter's output is a tty - colorizes the passed string - and output is not a tty, but --color option was provided - colorizes the passed string - and the formatter's output is not a tty - does nothing - when the global Rainbow.enabled is false - and the formatter's output is not a tty - does nothing - and the formatter's output is a tty - does nothing - #yellow - invokes #colorize(string, yellow - #blue - invokes #colorize(string, blue - #green - invokes #colorize(string, green - #cyan - invokes #colorize(string, cyan - #red - invokes #colorize(string, red - #magenta - invokes #colorize(string, magenta +RuboCop::Cop::Lint::TrailingCommaInAttributeDeclaration + registers an offense when using trailing comma + does not register an offense when not using trailing comma -RuboCop::Cop::InternalAffairs::InheritDeprecatedCopClass - registers an offense when using `RuboCop::Cop::Cop` - does not register an offense when not inherited super class - does not register an offense when using `Base` - registers an offense when using `Cop` +RuboCop::Cop::Lint::ShadowedException + single rescue + accepts rescuing a single custom exception + accepts rescuing multiple custom exceptions + accepts rescuing a custom exception and a standard exception + accepts splat arguments passed to rescue + accepts rescue containing multiple same error code exceptions + accepts rescuing a single exception + accepts an empty rescue + registers an offense rescuing exceptions that are ancestors of each other + accepts rescuing a multiple exceptions that are not ancestors that have an else + registers an offense for the same exception multiple times + registers an offense rescuing Exception with any other error or exception + rescue a exception without causing constant name deprecation warning + accepts rescuing a single exception that has an else + accepts rescuing a single exception that has an ensure + accepts rescuing a single exception that is assigned to a variable + when there are multiple levels of exceptions in the same rescue + registers an offense for more than two exceptions + registers an offense for two exceptions + modifier rescue + accepts rescue in its modifier form + multiple rescues + registers an offense rescuing out of order exceptions when there is an ensure + accepts rescuing a known exception after an unknown exceptions + accepts rescuing exceptions in order of level + accepts rescuing exceptions in order of level with multiple exceptions in a group + accepts many (>= 7) rescue groups + registers an offense rescuing Exception before an unknown exceptions + registers an offense for two exceptions when there are multiple levels of exceptions in the same rescue + registers an offense when a higher level exception is rescued before a lower level exception when there are multiple exceptions rescued in a group + registers an offense when a higher level exception is rescued before a lower level exception + accepts rescuing a known exception between unknown exceptions + accepts rescuing a known exception before an unknown exceptions + accepts rescuing exceptions in order of level with multiple exceptions in a group with custom exceptions + accepts rescuing custom exceptions in multiple rescue groups + ignores expressions of non-const + exceptions from different ancestry chains + accepts rescuing exceptions in one order + accepts rescuing exceptions in another order + splat arguments + registers an offense for splat arguments rescued after rescuing Exception + accepts splat arguments passed to multiple rescues + does not register an offense for splat arguments rescued after rescuing a known exception + last rescue does not specify exception class + highlights range ending at rescue keyword -RuboCop::CommentConfig - #cop_enabled_at_line? - can handle double disable of one cop - supports disabling all cops except Lint/RedundantCopDisableDirective with keyword all - supports disabling cops with multiple uppercase letters - supports disabling cops with multiple levels in department name - does not confuse a cop name including "all" with all cops - supports enabling/disabling multiple cops in a single directive - supports enabling/disabling cops without a prefix - handles indented single line - supports disabling single line with a directive at end of line - supports disabling all lines after a directive - supports enabling/disabling multiple cops along with a comment - just ignores unpaired enabling directives - supports disabling cops with numbers in their name - supports disabling multiple lines with a pair of directive - supports disabling cops on a comment line with an EOL comment - does not confuse a comment directive embedded in a string literal with a real comment - #cop_disabled_line_ranges - collects line ranges by disabled cops - comment_only_line? - when line contains code and comment - returns false - when line contains only comment - returns true - returns true - when line is empty - returns true - when line contains only code - returns false - returns false - returns false - returns false - #extra_enabled_comments - has values as arrays of extra enabled cops - has keys as instances of Parser::Source::Comment for extra enabled comments - -RuboCop::Cop::Lint::MissingSuper - callbacks - registers no offense when module callback without `super` call - registers an offense when class callback without `super` call - registers an offense when class callback within `self << class` and without `super` call - does not register an offense when callback has a `super` call - registers an offense when method callback is without `super` call - constructor - does not register an offense for the constructor-like method defined outside of a class - does not register an offense for the class without parent class - does not register an offense for the class with stateless parent class - does not register an offense when there is a `super` call - registers an offense when no `super` call - -RuboCop::Server::CLI - when using server option with `--cache-root=path` option - returns exit status 0 and display an information message - when not using any server options and specifying `--server` in .rubocop file - returns exit status 0 and display an information message - when using `--stop-server` option - returns exit status 0 and display a warning message - when using `--no-server` option - returns exit status 0 - when using `--server` option - returns exit status 0 and display an information message - when using `--restart-server` option - returns exit status 0 and display an information and a warning messages - when not using any server options and specifying `--server` in `RUBOCOP_OPTS` environment variable - returns exit status 0 and display an information message - when using exclusive `--restart-server` option - returns exit status 2 and display an error message - when using server option with `--cache-root path` option - returns exit status 0 and display an error message - when using `--server-status` option - returns exit status 0 and display an information message - when using multiple server options - returns exit status 2 and display an error message - when not using any server options - returns exit status 0 - when using `--start-server` option - returns exit status 0 and display an information message - when using exclusive `--stop-server` option - returns exit status 2 and display an error message - when using exclusive `--start-server` option - returns exit status 2 and display an error message - when using exclusive `--server-status` option - returns exit status 2 and display an error message - -RuboCop::Cop::Style::OrAssignment - when using var = var ? var : something - registers an offense with normal variables - registers an offense with class variables - does not register an offense if any of the variables are different - registers an offense with global variables - registers an offense with instance variables - when using var = if var; var; else; something; end - does not register an offense if any of the variables are different - registers an offense with normal variables - registers an offense with instance variables - registers an offense with global variables - registers an offense with class variables - when using var = something unless var - registers an offense for global variables - does not register an offense if any of the variables are different - registers an offense for instance variables - registers an offense for class variables - registers an offense for normal variables - when using `elsif` statement - does not register an offense - when using unless var; var = something; end - registers an offense for instance variables - registers an offense for global variables - registers an offense for class variables - registers an offense for normal variables - does not register an offense if any of the variables are different - when `then` branch body is empty - registers an offense - -RuboCop::Cop::Lint::UnderscorePrefixedVariableName - in a method calling `super` with arguments - when an underscore-prefixed argument is not used - does not register an offense - when an underscore-prefixed argument is used explicitly - registers an offense - when an underscore-prefixed named capture variable is used - registers an offense - in a method calling `binding` with arguments - when an underscore-prefixed argument is used explicitly - registers an offense - when an underscore-prefixed argument is not used - does not register an offense - when an underscore-prefixed variable is used - registers an offense - when non-underscore-prefixed variable is used - does not register an offense - when an underscore-prefixed variable is captured by a block - accepts - when an underscore-prefixed method argument is used - registers an offense - when an underscore-prefixed variable in top-level scope is used - registers an offense - when an underscore-prefixed keyword block argument is used - registers an offense - when AllowKeywordBlockArguments is set - does not register an offense - when an underscore-prefixed block argument is used - registers an offense - registers an offense - in a method calling `super` without arguments - when an underscore-prefixed argument is not used explicitly - does not register an offense - when an underscore-prefixed argument is used explicitly - registers an offense - in a method calling `binding` without arguments - when an underscore-prefixed argument is used explicitly - registers an offense - when an underscore-prefixed argument is not used explicitly - does not register an offense - when an underscore-prefixed variable is reassigned - does not register an offense - -RuboCop::Runner - #run with cops autocorrecting each-other - with two pairs of conflicting cops - with display options - --display-only-correctable - returns false - ommits uncorrectable `Layout/LineLength` - --display-only-safe-correctable - returns false - ommits unsafe correctable `Style/FrozenStringLiteral` - with three cop cycle - if there is an offense in an inspected file - aborts because of an infinite loop - if there is an offense in an inspected file - aborts because of an infinite loop - with two conflicting cops - if there is an offense in an inspected file - aborts because of an infinite loop - if there are multiple offenses in an inspected file - aborts because of an infinite loop - #run when interrupted - with SIGINT - returns false - #run - if there is an offense in an inspected file - sends the offense to a formatter - returns false - if a cop crashes - does not call ResultCache#save - if -s/--stdin is used with an offense - sends the offense to a formatter - returns false - if there are no offenses in inspected files - returns true - -RuboCop::Cop::Force - .force_name - returns the class name without namespace - #run_hook - invokes a hook in all cops - -RuboCop::Cop::Lint::SafeNavigationWithEmpty - outside a conditional - registers no offense - in a conditional - does not register an offense on `.empty?` - registers an offense and corrects on `&.empty?` - -RuboCop::Cop::Style::HashExcept - does not register an offense when using `reject` and comparing with `:key != lvar` - does not register an offense when using `select` and comparing with `lvar == :key` - does not register an offense when using `select` and comparing with `:key == lvar` - does not register an offense when using `reject` and comparing with `lvar != :key` - does not register an offense when using `reject` and `include?` - does not register an offense when using `Hash#except` - does not register an offense when not using key block argument` - does not register an offense when not using block` - Ruby 3.0 or higher - registers and corrects an offense when using `reject` and comparing with `:sym == lvar` - registers and corrects an offense when using `select` and comparing with `:sym != lvar` - registers and corrects an offense when using `reject` and other than comparison by string and symbol using `eql?` - does not register an offense when using `keep_if` and comparing with `lvar != :sym` - does not register an offense when using `reject` and other than comparison by string and symbol using `==` - does not register an offense when using `delete_if` and comparing with `lvar == :sym` - registers and corrects an offense when using `reject` and comparing with `lvar == :sym` - registers and corrects an offense when using `select` and comparing with `lvar != :sym` - registers and corrects an offense when using `reject` and comparing with `lvar == 'str'` - registers and corrects an offense when using `filter` and comparing with `lvar != :sym` - does not register an offense when comparing with hash value - when `AllCops/ActiveSupportExtensionsEnabled: true` - registers and corrects an offense when using `reject` and comparing with `lvar == 'str'` - does not register an offense when comparing with hash value - does not register an offense when using `reject` and other than comparison by string and symbol using `==` - registers and corrects an offense when using `select` and comparing with `:sym != lvar` - registers and corrects an offense when using `filter` and comparing with `lvar != :sym` - registers and corrects an offense when using `select` and comparing with `lvar != :sym` - does not register an offense when using `delete_if` and comparing with `lvar == :sym` - does not register an offense when using `keep_if` and comparing with `lvar != :sym` - registers and corrects an offense when using `reject` and other than comparison by string and symbol using `eql?` - registers and corrects an offense when using `reject` and comparing with `lvar == :sym` - registers and corrects an offense when using `reject` and comparing with `:sym == lvar` - using `exclude?` - registers and corrects an offense when using `select` and calling `exclude?` method with symbol array - registers and corrects an offense when using `reject` and calling `!exclude?` method with symbol array - does not register an offense when using `reject` and calling `exclude?` method with symbol array and second block value - registers and corrects an offense when using `filter` and calling `exclude?` method with symbol array - registers and corrects an offense when using `reject` and calling `!exclude?` method with dynamic symbol array - registers and corrects an offense when using `reject` and calling `!exclude?` method with method call - registers and corrects an offense when using `reject` and calling `!exclude?` method with dynamic string array - registers and corrects an offense when using `reject` and calling `!exclude?` method with variable - using `in?` - does not register an offense when using `reject` and calling `in?` method with symbol array and second block value - registers and corrects an offense when using `reject` and calling `key.in?` method with symbol array - registers and corrects an offense when using `reject` and calling `key.in?` method with dynamic symbol array - registers and corrects an offense when using `reject` and calling `key.in?` method with variable - registers and corrects an offense when using `reject` and calling `key.in?` method with dynamic string array - registers and corrects an offense when using `filter` and calling `!key.in?` method with symbol array - registers and corrects an offense when using `reject` and calling `key.in?` method with method call - registers and corrects an offense when using `select` and calling `!key.in?` method with symbol array - using `include?` - registers and corrects an offense when using `reject` and calling `include?` method with dynamic string array - registers and corrects an offense when using `select` and calling `!include?` method with symbol array - registers and corrects an offense when using `reject` and calling `include?` method with symbol array - registers and corrects an offense when using `reject` and calling `include?` method with method call - registers and corrects an offense when using `filter` and calling `!include?` method with symbol array - registers and corrects an offense when using `reject` and calling `include?` method with dynamic symbol array - registers and corrects an offense when using `reject` and calling `include?` method with variable - using `in?` - does not register offenses when using `reject` and calling `key.in?` method with symbol array - using `exclude?` - does not register offenses when using `reject` and calling `!exclude?` method with symbol array - using `include?` - registers and corrects an offense when using `reject` and calling `include?` method with symbol array - registers and corrects an offense when using `select` and calling `!include?` method with symbol array - registers and corrects an offense when using `reject` and calling `include?` method with method call - registers and corrects an offense when using `reject` and calling `include?` method with dynamic string array - registers and corrects an offense when using `reject` and calling `include?` method with variable - does not register an offense when using `reject` and calling `include?` method with symbol array and second block value - registers and corrects an offense when using `filter` and calling `!include?` method with symbol array - registers and corrects an offense when using `reject` and calling `include?` method with dynamic symbol array - Ruby 2.7 or lower - does not register an offense when using `select` and comparing with `:key != lvar` - does not register an offense when using `reject` and comparing with `lvar == :key` - does not register an offense when using `reject` and comparing with `:key == lvar` - does not register an offense when using `select` and comparing with `lvar != :key` - -RuboCop::Cop::Naming::BlockForwarding - when `EnforcedStyle: anonymous - Ruby < 3.0 - does not register an offense when not using anonymous block forwarding - Ruby >= 3.1 - does not register an offense when defining no arguments method - registers and corrects an offense when using explicit block forwarding - does not register an offense when using anonymous block forwarding without method body - does not register an offense when defining without block argument method - does not register an offense when defining kwoptarg with block args method - registers and corrects an offense when using symbol proc argument in method body - does not register an offense when assigning the block arg - registers and corrects an offense when using `yield` in method body - registers and corrects an only explicit block forwarding when using multiple proc arguments - does not register an offense when defining kwarg with block args method - does not register an offense when using block argument as a variable - registers and corrects an offense when using explicit block forwarding without method body - registers and corrects an offense when using explicit block forwarding without method definition parentheses - does not register an offense when using anonymous block forwarding - registers and corrects an offense when using explicit block forwarding in singleton method - when `EnforcedStyle: explicit - Ruby >= 3.1 - registers and corrects an offense when using anonymous block forwarding in singleton method - registers and corrects and corrects an offense when using anonymous block forwarding without method body - does not register an offense when using explicit block forwarding - does not register an offense when using explicit block forwarding without method body - does not register an offense when defining without block argument method - registers and corrects an offense when using symbol proc argument in method body - does not register an offense when assigning the block arg - registers and corrects an offense when using anonymous block forwarding - registers and corrects an offense when using `yield` in method body - when `BlockForwardingName: proc - registers and corrects an offense when using anonymous block forwarding - when `BlockForwardingName: block` is already in use - registers and no corrects an offense when using anonymous block forwarding - -RuboCop::Cop::Lint::RedundantWithIndex - registers an offense when using `ary.each.with_index(1) { |v| v }` and correct to `ary.each { |v| v }` - registers an offense when using `ary.each.with_index { |v| v }` and corrects to `ary.each` - registers an offense when using `ary.each_with_object([]).with_index { |v| v }` and corrects to `ary.each_with_object([]) { |v| v }` - accepts an index is used as a block argument - registers an offense for `ary.each_with_index { |v| v }` and corrects to `ary.each` - Ruby 2.7 - accepts an index is used as a numblock argument - registers an offense for `ary.each_with_index { _1 }` and corrects to `ary.each` - registers an offense when using `ary.each.with_index { _1 }` and corrects to `ary.each` - -RuboCop::Cop::InternalAffairs::RedundantMethodDispatchNode - does not register an offense when using `send_node.method_name` - does not register an offense when using `node.receiver` - registers an offense when using `node.send_node.receiver` - does not register an offense when using `node.method_name` - registers an offense when using `node.send_node.method_name` - does not register an offense when using `node.send_node.arguments?` - -RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral - accepts non array percent literals - for W type and ["{", "}"] delimiters - registers an offense for unnecessary spaces - accepts literals with escaped and additional spaces - registers an offense for multiple spaces between items - accepts literals without additional spaces - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - accepts multi-line literals - accepts multi-line literals within a method - for I type and ["{", "}"] delimiters - accepts multi-line literals within a method - accepts multi-line literals - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - registers an offense for unnecessary spaces - registers an offense for multiple spaces between items - accepts literals without additional spaces - accepts literals with escaped and additional spaces - for w type and ["(", ")"] delimiters - accepts multi-line literals within a method - registers an offense for unnecessary spaces - accepts literals with escaped and additional spaces - accepts multi-line literals - accepts literals without additional spaces - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - registers an offense for multiple spaces between items - for W type and ["(", ")"] delimiters - registers an offense for multiple spaces between items - accepts multi-line literals within a method - accepts newlines and additional following alignment spaces - registers an offense for unnecessary spaces - accepts literals without additional spaces - accepts multi-line literals - accepts literals with escaped and additional spaces - accepts literals with escaped spaces - for i type and ["[", "]"] delimiters - accepts literals without additional spaces - accepts literals with escaped and additional spaces - accepts newlines and additional following alignment spaces - accepts literals with escaped spaces - registers an offense for multiple spaces between items - registers an offense for unnecessary spaces - accepts multi-line literals - accepts multi-line literals within a method - for i type and ["!", "!"] delimiters - registers an offense for multiple spaces between items - accepts multi-line literals within a method - accepts literals without additional spaces - registers an offense for unnecessary spaces - accepts newlines and additional following alignment spaces - accepts multi-line literals - accepts literals with escaped spaces - accepts literals with escaped and additional spaces - for W type and ["!", "!"] delimiters - accepts multi-line literals within a method - accepts multi-line literals - accepts literals with escaped and additional spaces - registers an offense for unnecessary spaces - accepts literals with escaped spaces - accepts literals without additional spaces - registers an offense for multiple spaces between items - accepts newlines and additional following alignment spaces - for i type and ["(", ")"] delimiters - accepts multi-line literals within a method - accepts literals without additional spaces - registers an offense for multiple spaces between items - registers an offense for unnecessary spaces - accepts literals with escaped spaces - accepts multi-line literals - accepts literals with escaped and additional spaces - accepts newlines and additional following alignment spaces - for W type and ["[", "]"] delimiters - registers an offense for unnecessary spaces - accepts literals with escaped and additional spaces - accepts multi-line literals - accepts multi-line literals within a method - accepts literals with escaped spaces - accepts literals without additional spaces - registers an offense for multiple spaces between items - accepts newlines and additional following alignment spaces - for w type and ["{", "}"] delimiters - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - accepts literals with escaped and additional spaces - accepts literals without additional spaces - accepts multi-line literals within a method - accepts multi-line literals - registers an offense for multiple spaces between items - registers an offense for unnecessary spaces - for I type and ["!", "!"] delimiters - accepts literals with escaped spaces - registers an offense for multiple spaces between items - registers an offense for unnecessary spaces - accepts literals without additional spaces - accepts newlines and additional following alignment spaces - accepts literals with escaped and additional spaces - accepts multi-line literals within a method - accepts multi-line literals - for i type and ["{", "}"] delimiters - accepts newlines and additional following alignment spaces - registers an offense for unnecessary spaces - registers an offense for multiple spaces between items - accepts multi-line literals - accepts multi-line literals within a method - accepts literals without additional spaces - accepts literals with escaped and additional spaces - accepts literals with escaped spaces - for w type and ["[", "]"] delimiters - registers an offense for unnecessary spaces - registers an offense for multiple spaces between items - accepts literals with escaped and additional spaces - accepts literals without additional spaces - accepts multi-line literals - accepts literals with escaped spaces - accepts newlines and additional following alignment spaces - accepts multi-line literals within a method - for I type and ["(", ")"] delimiters - registers an offense for unnecessary spaces - accepts newlines and additional following alignment spaces - registers an offense for multiple spaces between items - accepts multi-line literals within a method - accepts literals with escaped and additional spaces - accepts literals with escaped spaces - accepts multi-line literals - accepts literals without additional spaces - for w type and ["!", "!"] delimiters - accepts literals without additional spaces - accepts newlines and additional following alignment spaces - registers an offense for multiple spaces between items - accepts multi-line literals - accepts literals with escaped and additional spaces - accepts literals with escaped spaces - registers an offense for unnecessary spaces - accepts multi-line literals within a method - for I type and ["[", "]"] delimiters - accepts multi-line literals within a method - accepts literals without additional spaces - accepts multi-line literals - accepts literals with escaped and additional spaces - accepts literals with escaped spaces - registers an offense for unnecessary spaces - accepts newlines and additional following alignment spaces - registers an offense for multiple spaces between items - -RuboCop::Cop::Style::StderrPuts - registers no offense when using `STDERR.puts` with no arguments - registers an offense when using `$stderr.puts('hello')` - registers no offense when using `$stderr.puts` with no arguments - registers an offense when using `::STDERR.puts('hello')` - registers an offense when using `STDERR.puts('hello')` - -RuboCop::Cop::Style::ArrayCoercion - does not register an offense when splatting multiple variables into array - does not register an offense when splat is not in array - does not register an offense when converting variable into other named array variable with check - registers an offense and corrects when splatting variable into array - registers an offense and corrects when converting variable into array with check - -RuboCop::Cop::Style::IpAddresses - does not register an offense on an empty string - with allowed addresses - does not register an offense for a allowed addresses - does not register an offense if the case differs - IPv4 - does not register an offense for an address inside larger text - registers an offense for a valid address - does not register an offense for an invalid address - IPv6 - registers an offense for a shortened address - registers an offense for a very short address - does not register an offense for an invalid address - registers an offense for a valid address - registers an offense for an address with 0s collapsed - registers an offense for the loopback address - the unspecified address :: (shortform of 0:0:0:0:0:0:0:0) - does not register an offense - when it is removed from the allowed addresses - registers an offense - -RuboCop::Cop::Style::ConditionalAssignment - SingleLineConditionsOnly false - corrects assignment to an if elsif else with multiple elsifs - corrects assignment to an unless else condition - corrects assignment to a case when else condition - corrects assignment to a case when else with multiple whens - corrects assignment to a multiline if else condition - corrects assignment to a multiline if elsif else condition - behaves like all variable types - registers an offense assigning any variable type to if else - allows assignment to if without else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to unless else - does not crash for rescue assignment - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to if elsif else - registers an offense for assigning any variable type to case when - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all variable types - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to if elsif else - allows assignment to if without else - registers an offense assigning any variable type to if elsewith multiple assignment - does not crash for rescue assignment - registers an offense assigning any variable type to unless else - registers an offense for assigning any variable type to case when - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - allows any assignment to if without else - registers an offense for any assignment to ternary - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline if else - any assignment to a multiline case when - behaves like multiline all variable types offense - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - assigning any variable type to a multiline if elsif else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline case when - behaves like multiline all variable types offense - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - assigning any variable type to a multiline case when - behaves like all assignment types - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - allows any assignment to if without else - does not crash when used inside rescue - registers an offense any assignment to case when - registers an offense any assignment to if else - behaves like multiline all variable types offense - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline if else - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline case when - assigning any variable type to a multiline unless else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to ternary - allows any assignment to if without else - registers an offense for any assignment to unless else - behaves like all assignment types - allows any assignment to if without else - registers an offense any assignment to case when - does not crash when used inside rescue - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like all assignment types - allows any assignment to if without else - registers an offense for any assignment to ternary - registers an offense any assignment to case when - registers an offense for any assignment to unless else - does not crash when used inside rescue - registers an offense any assignment to if else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to case when - registers an offense for any assignment to unless else - allows any assignment to if without else - registers an offense any assignment to if else - registers an offense for any assignment to ternary - behaves like multiline all assignment types offense - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like all variable types - registers an offense assigning any variable type to unless else - does not crash for rescue assignment - registers an offense assigning any variable type to ternary - registers an offense for assigning any variable type to case when - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to if elsif else - allows assignment to if without else - registers an offense assigning any variable type to if else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to ternary - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to unless else - does not crash when used inside rescue - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline if else - any assignment to a multiline case when - behaves like single line condition autocorrect - corrects assignment to an if elsif else condition - corrects assignment to a case when else condition - corrects assignment to an unless else condition - corrects assignment to an if elsif else with multiple elsifs - corrects assignment to an if else condition - corrects assignment to a ternary operator - corrects assignment to a case when else with multiple whens - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense for any assignment to unless else - allows any assignment to if without else - registers an offense for any assignment to ternary - registers an offense any assignment to case when - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like multiline all variable types offense - assigning any variable type to a multiline if else - assigning any variable type to a multiline case when - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline unless else - assigning any variable type to an if else with multiline in one branch - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline if else - any assignment to a multiline case when - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all assignment types - registers an offense any assignment to case when - registers an offense for any assignment to ternary - does not crash when used inside rescue - allows any assignment to if without else - registers an offense any assignment to if else - registers an offense for any assignment to unless else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like multiline all variable types offense - assigning any variable type to a multiline if elsif else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline if else - assigning any variable type to a multiline case when - assigning any variable type to a multiline unless else - behaves like all variable types - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to if elsif else - registers an offense for assigning any variable type to case when - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to unless else - does not crash for rescue assignment - allows assignment to if without else - registers an offense assigning any variable type to ternary - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - does not crash when used inside rescue - behaves like multiline all assignment types offense - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like all assignment types - allows any assignment to if without else - registers an offense for any assignment to unless else - registers an offense any assignment to case when - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense for any assignment to ternary - behaves like all variable types - does not crash for rescue assignment - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to unless else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to if else - allows assignment to if without else - registers an offense for assigning any variable type to case when - registers an offense assigning any variable type to ternary - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like multiline all variable types offense - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - assigning any variable type to a multiline if elsif else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline case when - behaves like all variable types - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to unless else - does not crash for rescue assignment - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to ternary - allows assignment to if without else - registers an offense for assigning any variable type to case when - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all assignment types - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - does not crash when used inside rescue - allows any assignment to if without else - registers an offense any assignment to case when - registers an offense any assignment to if else - behaves like all assignment types - allows any assignment to if without else - registers an offense any assignment to if else - does not crash when used inside rescue - registers an offense any assignment to case when - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - allows any assignment to if without else - registers an offense for any assignment to ternary - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like multiline all variable types offense - assigning any variable type to a multiline case when - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - assigning any variable type to a multiline if elsif else - behaves like all variable types - registers an offense for assigning any variable type to case when - does not crash for rescue assignment - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to ternary - allows assignment to if without else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to unless else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - allows any assignment to if without else - does not crash when used inside rescue - registers an offense any assignment to case when - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to ternary - does not crash when used inside rescue - allows any assignment to if without else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - behaves like multiline all assignment types offense - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like all assignment types - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - allows any assignment to if without else - does not crash when used inside rescue - behaves like all assignment types - registers an offense any assignment to if else - does not crash when used inside rescue - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - behaves like multiline all assignment types offense - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all assignment types - registers an offense for any assignment to unless else - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to ternary - allows any assignment to if without else - does not crash when used inside rescue - SingleLineConditionsOnly true - registers an offense for assignment using a method that ends with an equal sign - corrects assignment to a namespaced constant - registers an offense for assignment using []= - corrects assignment when without `else` branch - registers an offense for assignment to an if then else - allows a method call in the subject of a ternary operator - registers an offense for assignment to case when then else - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like multiline all variable types allow - assigning any variable type to a multiline case when - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline if elsif else - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to unless else - allows any assignment to if without else - registers an offense any assignment to case when - does not crash when used inside rescue - registers an offense for any assignment to ternary - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like all assignment types - registers an offense for any assignment to unless else - does not crash when used inside rescue - registers an offense any assignment to case when - registers an offense any assignment to if else - registers an offense for any assignment to ternary - allows any assignment to if without else - behaves like multiline all variable types allow - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline unless else - assigning any variable type to a multiline case when - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline if else - behaves like all variable types - registers an offense assigning any variable type to if else - does not crash for rescue assignment - registers an offense assigning any variable type to unless else - registers an offense for assigning any variable type to case when - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to if elsewith multiple assignment - allows assignment to if without else - registers an offense assigning any variable type to ternary - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like multiline all assignment types allow - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all variable types - allows assignment to if without else - does not crash for rescue assignment - registers an offense assigning any variable type to if else - registers an offense for assigning any variable type to case when - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to unless else - registers an offense assigning any variable type to if elsif else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - does not crash when used inside rescue - allows any assignment to if without else - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline unless else - any assignment to a multiline case when - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline unless else - any assignment to a multiline if else - behaves like all variable types - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to unless else - registers an offense assigning any variable type to ternary - registers an offense for assigning any variable type to case when - does not crash for rescue assignment - registers an offense assigning any variable type to if else - allows assignment to if without else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - registers an offense any assignment to case when - allows any assignment to if without else - does not crash when used inside rescue - behaves like multiline all assignment types allow - any assignment to a multiline unless else - any assignment to a multiline if else - any assignment to a multiline case when - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types allow - any assignment to a multiline unless else - any assignment to a multiline if else - any assignment to a multiline case when - behaves like all assignment types - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to ternary - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense for any assignment to unless else - behaves like all variable types - registers an offense assigning any variable type to if elsif else - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to unless else - allows assignment to if without else - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense for assigning any variable type to case when - does not crash for rescue assignment - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to unless else - registers an offense any assignment to case when - registers an offense for any assignment to ternary - allows any assignment to if without else - does not crash when used inside rescue - behaves like all variable types - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to if else - registers an offense assigning any variable type to unless else - registers an offense for assigning any variable type to case when - does not crash for rescue assignment - registers an offense assigning any variable type to if elsewith multiple assignment - allows assignment to if without else - registers an offense assigning any variable type to if elsif else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like multiline all assignment types allow - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all assignment types - registers an offense any assignment to if else - registers an offense for any assignment to ternary - does not crash when used inside rescue - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to unless else - behaves like all assignment types - does not crash when used inside rescue - allows any assignment to if without else - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - registers an offense any assignment to case when - registers an offense any assignment to if else - behaves like multiline all variable types allow - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline case when - assigning any variable type to a multiline if else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline unless else - behaves like all assignment types - allows any assignment to if without else - registers an offense any assignment to if else - does not crash when used inside rescue - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - behaves like all assignment types - registers an offense for any assignment to unless else - registers an offense any assignment to case when - does not crash when used inside rescue - registers an offense any assignment to if else - allows any assignment to if without else - registers an offense for any assignment to ternary - behaves like single line condition autocorrect - corrects assignment to a case when else with multiple whens - corrects assignment to an unless else condition - corrects assignment to an if elsif else condition - corrects assignment to a ternary operator - corrects assignment to an if else condition - corrects assignment to an if elsif else with multiple elsifs - corrects assignment to a case when else condition - behaves like all assignment types - registers an offense any assignment to case when - registers an offense any assignment to if else - registers an offense for any assignment to ternary - registers an offense for any assignment to unless else - does not crash when used inside rescue - allows any assignment to if without else - behaves like all variable types - registers an offense assigning any variable type to if else - does not crash for rescue assignment - registers an offense assigning any variable type to unless else - registers an offense assigning any variable type to ternary - registers an offense for assigning any variable type to case when - allows assignment to if without else - registers an offense assigning any variable type to if elsewith multiple assignment - registers an offense assigning any variable type to if elsif else - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - for loop - ignores pseudo assignments in a for loop - behaves like all assignment types - registers an offense for any assignment to ternary - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense any assignment to if else - does not crash when used inside rescue - allows any assignment to if without else - behaves like all assignment types - does not crash when used inside rescue - allows any assignment to if without else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - behaves like multiline all variable types allow - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline case when - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if else - behaves like multiline all variable types allow - assigning any variable type to a multiline if else - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if elsif else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline case when - behaves like all variable types - registers an offense assigning any variable type to ternary - registers an offense assigning any variable type to unless else - registers an offense assigning any variable type to if elsif else - does not crash for rescue assignment - registers an offense assigning any variable type to if elsewith multiple assignment - allows assignment to if without else - registers an offense assigning any variable type to if else - registers an offense for assigning any variable type to case when - >= Ruby 2.7 - registers an offense for assigning any variable type to case in - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like all assignment types - registers an offense for any assignment to ternary - registers an offense any assignment to case when - registers an offense any assignment to if else - does not crash when used inside rescue - registers an offense for any assignment to unless else - allows any assignment to if without else - behaves like all assignment types - registers an offense for any assignment to unless else - does not crash when used inside rescue - registers an offense for any assignment to ternary - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense any assignment to if else - behaves like all assignment types - allows any assignment to if without else - registers an offense any assignment to if else - does not crash when used inside rescue - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - registers an offense any assignment to case when - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline unless else - any assignment to a multiline if else - behaves like multiline all assignment types allow - any assignment to a multiline if else - any assignment to a multiline case when - any assignment to a multiline unless else - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like all assignment types - allows any assignment to if without else - registers an offense for any assignment to ternary - does not crash when used inside rescue - registers an offense for any assignment to unless else - registers an offense any assignment to if else - registers an offense any assignment to case when - behaves like multiline all assignment types allow - any assignment to a multiline unless else - any assignment to a multiline case when - any assignment to a multiline if else - behaves like all assignment types - does not crash when used inside rescue - registers an offense any assignment to if else - registers an offense any assignment to case when - registers an offense for any assignment to unless else - registers an offense for any assignment to ternary - allows any assignment to if without else - behaves like all assignment types - registers an offense for any assignment to unless else - does not crash when used inside rescue - registers an offense any assignment to case when - allows any assignment to if without else - registers an offense for any assignment to ternary - registers an offense any assignment to if else - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline unless else - any assignment to a multiline if else - behaves like multiline all variable types allow - assigning any variable type to a multiline if else - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline unless else - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline case when - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - behaves like multiline all variable types allow - assigning any variable type to an if else with multiline in one branch - assigning any variable type to a multiline unless else - assigning any variable type to a multiline case when - assigning any variable type to a multiline if elsif else - assigning any variable type to a multiline if else - behaves like multiline all assignment types allow - any assignment to a multiline case when - any assignment to a multiline if else - any assignment to a multiline unless else - IncludeTernaryExpressions false - allows assigning any variable type to ternary - -RuboCop::Cop::Bundler::OrderedGems - When a gem declaration takes several lines - registers an offense - When each individual group of line is not sorted - registers some offenses - When gems are alphabetically sorted - does not register any offenses - When gems are asciibetically sorted irrespective of _ - does not register an offense - When a gem is sorted but not so when disregarding _- - by default - registers an offense - when ConsiderPunctuation is true - does not register an offense - When a gem that starts with a capital letter is not sorted - registers an offense - When gems are not alphabetically sorted - registers an offense - when a gem is referenced from a variable - ignores the line - resets the sorting to a new block - When the gemfile is empty - does not register any offenses - When gems have an inline comment, and not sorted - registers an offense - When gem groups is separated by multiline comment - with TreatCommentsAsGroupSeparators: false - registers an offense - with TreatCommentsAsGroupSeparators: true - accepts - When a gem that starts with a capital letter is sorted - does not register an offense - When there are duplicated gems in group - registers an offense - When each individual group of line is sorted - does not register any offenses +RuboCop::CLI + does not register any offenses for an empty file + can process a file with an invalid UTF-8 byte sequence + checks a given file with faults and returns 1 + registers an offense for a syntax error + finds a file with no .rb extension but has a shebang line + registers an offense for Parser warnings + when errors are raised while processing files due to bugs + displays an error message to stderr + configuration of `AutoCorrect` + when setting `AutoCorrect: false` for `Style/StringLiterals` + does not suggest `1 offense autocorrectable` for `Style/StringLiterals` + when checking a correct file + returns 0 + when super is used with a block + still returns 0 + configuration of `require` + unknown library is specified + exits with 2 + style guide only usage + via the cli option + --only-guide-cops + runs cops for rules that link to a style guide + skips cops that have no link to a style guide + overrides configuration of AllCops/StyleGuideCopsOnly + via the config + AllCops/DisabledByDefault + when it is false + runs all cops that are enabled in default configuration + when it is true + runs only the cop configured in .rubocop.yml + AllCops/StyleGuideCopsOnly + when it is true + skips cops that have no link to a style guide + when it is false + runs cops for rules regardless of any link to the style guide + rubocop:disable comment + can disable all cops in a code section + can disable selected cops on a single line + can disable all cops on a single line + can disable selected cops in a code section + without using namespace + can disable selected cops on a single line but prints a warning + when --autocorrect-all is given + does not trigger RedundantCopDisableDirective due to lines moving around + when not necessary + causes an offense to be reported + and RedundantCopDisableDirective is disabled through department + does not report RedundantCopDisableDirective offenses + and RedundantCopDisableDirective is individually disabled + does not report RedundantCopDisableDirective offenses + when using `rubocop:disable` line comment for `Style/RedundantInitialize` + does not register an offense for `Lint/RedundantCopDisableDirective` + when using `rubocop:disable` line comment for `Lint/EmptyBlock` + does not register an offense for `Lint/RedundantCopDisableDirective` + and RedundantCopDisableDirective is individually excluded + does not report RedundantCopDisableDirective offenses + and there are no other offenses + exits with error code + Specify `--init` option to `rubocop` command + when .rubocop.yml already exists + fails with an error message + when .rubocop.yml does not exist + generate a .rubocop.yml file + when parallel static by default + when specifying `--debug` and `-a` options` + uses parallel inspection when correcting the file + when setting `UseCache: false` + fails with an error message + when setting `UseCache: true` + fails with an error message + when specifying `--debug` option only` + fails with an error message + when given a file/directory that is not under the current dir + and the Rakefile path is absolute + checks a Rakefile but Style/FileName does not report + and the directory is relative + checks a Rakefile but Style/FileName does not report + and the directory is absolute + checks a Rakefile but Style/FileName does not report + and the Rakefile path is relative + checks a Rakefile but Style/FileName does not report + info severity + when there are not only info offenses + returns a 1 code + when given `--display-only-fail-level-offenses` + returns a 0 code but does not list offenses + when `Lint/Syntax` is given `Severity: info` + is an invalid configuration + when there are only info offenses + returns a 0 code + when given `--fail-level info` + returns a 1 code + when lines end with CR+LF + reports an offense + configuration from file + works when a cop that others depend on is disabled + allows the default configuration file as the -c argument + only reads configuration in explicitly included hidden directories + fails when a configuration file has invalid YAML syntax + ignores excluded files + can exclude a vendor directory indirectly + prints a warning for an unrecognized configuration parameter + can be configured with option to disable a certain error + can disable parser-derived offenses with warning severity + can exclude a vendor directory with an erroneous config file + finds included files + displays style guide URLs if DisplayStyleGuide is true + can be configured to override a parameter that is a hash in a special case + matches included/excluded files correctly when . argument is given + can exclude a typical vendor directory + does not consider Include parameters in subdirectories + can have different config files in different directories + displays cop names if DisplayCopNames is false + can exclude directories relative to .rubocop.yml + shows an error if the input file cannot be found + cannot disable Syntax offenses + prints an error for an unrecognized cop name in .rubocop.yml + prints an error message for an unrecognized EnforcedStyle + runs without errors for an unrecognized cop name in .rubocop.yml and `--ignore-unrecognized-cops` option is given + uses the DefaultFormatter if another formatter is not specified + fails when a configuration file specifies an invalid Severity + works when a configuration file specifies Severity for Metrics/ParameterLists and Layout/LineLength + can use an alternative max line length from a config file + works when a configuration file passed by -c specifies Exclude with regexp + works when a configuration file passed by -c specifies Exclude with strings + excludes the vendor directory by default + works when a configuration file specifies Severity for Metrics/ParameterLists and Layout + can be configured with project config to disable a certain error + prefers a config file in ancestor directory to another in home + can be configured to merge a parameter that is a hash + does not read files in excluded list + when obsolete MultiSpaceAllowedForOperators param is used + displays a warning + without using namespace + can be configured with option to disable a certain error + when configured for indented_internal_methods style indentation + accepts indented_internal_methods style indentation + registers offense for normal indentation in module + registers offense for normal indentation in class + when MultilineMethodCallIndentation is used with aligned style and IndentationWidth parameter + fails with an error message + when a file inherits from a higher level + inherits relative excludes correctly + when --force-default-config option is specified + when no config file specified + ignores config file + when config file specified with -c + ignores config file + when MultilineOperationIndentation is used with aligned style and IndentationWidth parameter + fails with an error message + when a value in a hash is overridden with nil + acts as if the key/value pair was removed + when configuration is taken from $HOME/.rubocop.yml + handles relative excludes correctly when run from project root + when a directory is named `*` + does not crash + cops can exclude files based on config + ignores excluded files + obsolete cops + when configuration for TrailingComma is given + fails with an error message + configuration of target Ruby versions + when configured with an unknown version + fails with an error message + when configured with an unsupported ruby + fails with an error message + unknown cop + in configuration file is given + prints the error and exists with code 2 + when interrupted + returns 130 + for a disabled cop + reports no offense when enabled on part of a file -RuboCop::Cop::Lint::StructNewOverride - registers an offense using `Struct.new(string, ...symbols)` - registers an offense using `Struct.new(...)` with an option argument - registers an offense using `Struct.new(...symbols)` - registers an offense using `Struct.new(...)` with a block - registers an offense using `::Struct.new(symbol)` - registers an offense using `Struct.new(...)` with multiple overrides - registers an offense using `Struct.new(symbol, string)` - does not register an offense with no overrides - does not register an offense with an override within a given block - registers an offense using `Struct.new(symbol)` +RuboCop::Cop::InternalAffairs::UselessRestrictOnSend + does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` with alias_method + does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` with alias_method + does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` with alias + does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` with alias + does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` + registers an offense when using `RESTRICT_ON_SEND` and not defines send callback method + does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` -RuboCop::Cop::Lint::SuppressedException - with AllowComments set to true - does not register an offense for empty rescue with comment - registers an offense for empty rescue on single line with a comment after it - when empty rescue for `def` - does not register an offense for empty rescue with comment - registers an offense for empty rescue without comment - Ruby 2.7 or higher - when empty rescue for `do` block with a numbered parameter - registers an offense for empty rescue without comment - does not register an offense for empty rescue with comment - Ruby 2.5 or higher - when empty rescue for `do` block - registers an offense for empty rescue without comment - does not register an offense for empty rescue with comment - when empty rescue for `defs` - registers an offense for empty rescue without comment - does not register an offense for empty rescue with comment - with AllowComments set to false - registers an offense for empty rescue block - does not register an offense for rescue with body - when empty rescue for defs - registers an offense for empty rescue with comment - registers an offense for empty rescue without comment - when empty rescue for `def` - registers an offense for empty rescue without comment - registers an offense for empty rescue with comment - with AllowNil set to false - registers an offense for inline nil rescue - registers an offense for rescue block with nil - with AllowNil set to true - does not register an offense for inline nil rescue - does not register an offense for rescue block with nil - Ruby 2.5 or higher - when empty rescue for `do` block - registers an offense for empty rescue with comment - registers an offense for empty rescue without comment +RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage + does not register an offense when no `RUBY_VERSION` + registers an offense when using `::RUBY_VERSION` + registers an offense when using `RUBY_VERSION` -RuboCop::Cop::Style::MissingRespondToMissing - allows method_missing and respond_to_missing? when defined with inline access modifier and method_missing is not qualified by inline access modifier - registers an offense when respond_to_missing? is not implemented - allows method_missing and respond_to_missing? implemented as instance methods - allows method_missing and respond_to_missing? implemented as class methods - registers an offense respond_to_missing? is implemented as a class method and method_missing is implemented as an instance method - registers an offense when method_missing is implemented as a class methods - allows method_missing and respond_to_missing? when defined with inline access modifier - registers an offense respond_to_missing? is implemented as an instance method and method_missing is implemented as a class method +RuboCop::Formatter::FileListFormatter + #file_finished + displays parsable text -RuboCop::Cop::VisibilityHelp - #node_visibility - with inline public - is expected to eq :public - without visibility block - is expected to eq :public - with visibility block private - is expected to eq :private - with inline private - is expected to eq :private - with visibility block private after public - is expected to eq :private - with inline private with symbol - is expected to eq :private - with visibility block public - is expected to eq :public +RuboCop::Cop::InternalAffairs::RedundantContextConfigParameter + registers an offense when using `:config` parameter + registers an offense when using `:config` parameter with other parameters + does not register an offense when using `:config` in other than `context` + does not register an offense when using `:ruby30` only + does not register an offense when not using `:config` -RuboCop::Formatter::FormatterSet - responds to all formatter API methods - #close_output_files - does not close non file output - closes all output files - add_formatter - can add multiple formatters by being invoked multiple times - adds a formatter to itself - adds a formatter with specified formatter type - when output path is omitted - adds a formatter outputs to $stdout - when output path is specified - adds a formatter outputs to the specified file - when parent directories don't exist - creates them - formatter API method - invokes the same method of all containing formatters - #builtin_formatter_class - returns class which matches single character alias name - returns class which matches double character alias name - returns class which matches passed alias name exactly - #custom_formatter_class - can handle top level namespaced constant name - can handle namespaced constant name - returns constant represented by the passed string - when non-existent constant name is passed - raises error +RuboCop::Formatter::FuubarStyleFormatter + #progressbar_color + when a convention offense is detected in a file + is yellow + when convention and error offenses are detected in a file + is red + when a offense is detected in a file and autocorrected + is green + when no offenses are detected in a file + is still green + initially + is green + when an error offense is detected in a file + is red + and then a convention offense is detected in the next file + is still red + #with_color + when color is disabled + outputs nothing + when color is enabled + outputs coloring sequence code at the beginning and the end RuboCop::Cop::RangeHelp - source indicated by #range_with_surrounding_comma - when side is :right - is expected to eq "Error," - when side is :both - is expected to eq ",Error," - when side is :left - is expected to eq ",Error" source indicated by #range_by_whole_lines - with a whole line except newline selected - with include_final_newline - is expected to eq "puts 'example'\n" - without include_final_newline - is expected to eq "puts 'example'" - when part of a single line is selected - without include_final_newline - is expected to eq "puts 'example'" - with include_final_newline - is expected to eq "puts 'example'\n" - with end of one line - without include_final_newline - is expected to eq "puts 'example'" - with include_final_newline - is expected to eq "puts 'example'\n" when source doesn't end with a newline with include_final_newline - is expected to eq 30 is expected to eq "newline_at_end" + is expected to eq 30 without include_final_newline is expected to eq "newline_at_end" + with parts of four lines + without include_final_newline + is expected to eq "puts 'example'\nputs 'another example'\n\nsomething_else" + with include_final_newline + is expected to eq "puts 'example'\nputs 'another example'\n\nsomething_else\n" with a whole line plus beginning of next line with include_final_newline is expected to eq "puts 'example'\nputs 'another example'\n" @@ -15559,283 +11670,608 @@ is expected to eq "puts 'example'\nputs 'another example'" with include_final_newline is expected to eq "puts 'example'\nputs 'another example'\n" - with parts of four lines + with a whole line except newline selected + without include_final_newline + is expected to eq "puts 'example'" with include_final_newline - is expected to eq "puts 'example'\nputs 'another example'\n\nsomething_else\n" + is expected to eq "puts 'example'\n" + when part of a single line is selected without include_final_newline - is expected to eq "puts 'example'\nputs 'another example'\n\nsomething_else" + is expected to eq "puts 'example'" + with include_final_newline + is expected to eq "puts 'example'\n" with beginning of one line with include_final_newline is expected to eq "puts 'another example'\n" without include_final_newline is expected to eq "puts 'another example'" + with end of one line + with include_final_newline + is expected to eq "puts 'example'\n" + without include_final_newline + is expected to eq "puts 'example'" + source indicated by #range_with_surrounding_comma + when side is :both + is expected to eq ",Error," + when side is :right + is expected to eq "Error," + when side is :left + is expected to eq ",Error" source indicated by #range_with_surrounding_space when passing range as a positional argument behaves like works with various `side`s when side is :right is expected to eq "a(2) " - when side is :both - is expected to eq " a(2) " when side is :left is expected to eq " a(2)" + when side is :both + is expected to eq " a(2) " when passing range as a kwarg behaves like works with various `side`s + when side is :right + is expected to eq "a(2) " when side is :left is expected to eq " a(2)" when side is :both is expected to eq " a(2) " - when side is :right - is expected to eq "a(2) " #range_with_comments_and_lines returns a range that includes related comments and whole lines -RuboCop::Cop::Naming::AsciiIdentifiers - when AsciiConstants is false - accepts constants with only ascii chars - registers an offense for a variable name with non-ascii chars - accepts identifiers with only ascii chars - does not get confused by a byte order mark - does not get confused by an empty file - registers an offense for a variable name with mixed chars - when AsciiConstants is true - does not get confused by an empty file - registers an offense for a constant name with non-ascii chars - registers an offense for a variable name with mixed chars - accepts identifiers with only ascii chars - registers an offense for a variable name with non-ascii chars - does not get confused by a byte order mark +RuboCop::Cop::Gemspec::DependencyVersion + with `EnforcedStyle: required` + with `AllowedGems` + registers an offense when adding dependency by parenthesized call without version specification excepts allowed gems + registers an offense when adding dependency without version specification excepts allowed gems + using add_development_dependency + does not register an offense when adding development dependency with tag specification + does not register an offense when adding development dependency by parenthesized call with branch specification + registers an offense when adding development dependency using git option without version specification + registers an offense when adding development dependency by parenthesized call without version specification + does not register an offense when adding development dependency with branch specification + does not register an offense when adding development dependency by parenthesized call with version specification + registers an offense when adding development dependency using git option by parenthesized call without version specification + does not register an offense when adding development dependency with commit ref specification + does not register an offense when adding development dependency by parenthesized call with commit ref specification + does not register an offense when adding development dependency by parenthesized call with tag specification + registers an offense when adding development dependency without version specification + does not register an offense when adding development dependency with version specification + using add_dependency + does not register an offense when adding dependency with commit ref specification + does not register an offense when adding dependency with tag specification + does not register an offense when adding dependency with branch specification + registers an offense when adding dependency using git option by parenthesized call without version specification + registers an offense when adding dependency without version specification + does not register an offense when adding dependency with version specification + does not register an offense when adding dependency by parenthesized call with commit ref specification + does not register an offense when adding dependency by parenthesized call with branch specification + does not register an offense when adding dependency by parenthesized call with tag specification + registers an offense when adding dependency by parenthesized call without version specification + registers an offense when adding dependency using git option without version specification + does not register an offense when adding dependency by parenthesized call with version specification + using add_runtime_dependency + registers an offense when adding runtime dependency using git option by parenthesized call without version specification + does not register an offense when adding runtime dependency with version specification + registers an offense when adding runtime dependency by parenthesized call without version specification + does not register an offense when adding runtime dependency by parenthesized call with tag specification + does not register an offense when adding runtime dependency by parenthesized call with version specification + does not register an offense when adding runtime dependency by parenthesized call with branch specification + does not register an offense when adding runtime dependency with tag specification + registers an offense when adding runtime dependency using git option without version specification + does not register an offense when adding runtime dependency with commit ref specification + does not register an offense when adding runtime dependency by parenthesized call with commit ref specification + does not register an offense when adding runtime dependency with branch specification + registers an offense when adding runtime dependency without version specification + with `EnforcedStyle: forbidden` + with `AllowedGems` + registers an offense when adding dependency by parenthesized call without version specification + registers an offense when adding dependency without version specification + using add_dependency + does not register an offense when adding dependency by parenthesized call without version specification + registers an offense when adding dependency by parenthesized call with branch specification + does not register an offense when adding dependency using git option without version specification + does not register an offense when adding dependency using git option by parenthesized call without version specification + registers an offense when adding dependency with version specification + does not register an offense when adding dependency without version specification + registers an offense when adding dependency with commit ref specification + registers an offense when adding dependency by parenthesized call with version specification + registers an offense when adding dependency with tag specification + registers an offense when adding dependency by parenthesized call with tag specification + registers an offense when adding dependency with branch specification + registers an offense when adding dependency by parenthesized call with commit ref specification + using add_runtime_dependency + registers an offense when adding runtime dependency with commit ref specification + registers an offense when adding runtime dependency by parenthesized call with tag specification + registers an offense when adding runtime dependency with branch specification + registers an offense when adding runtime dependency with tag specification + does not register an offense when adding runtime dependency using git option by parenthesized call without version specification + registers an offense when adding runtime dependency by parenthesized call with branch specification + registers an offense when adding runtime dependency with version specification + does not register an offense when adding runtime dependency without version specification + registers an offense when adding runtime dependency by parenthesized call with commit ref specification + does not register an offense when adding runtime dependency using git option without version specification + registers an offense when adding runtime dependency by parenthesized call with version specification + does not register an offense when adding runtime dependency by parenthesized call without version specification + using add_development_dependency + does not register an offense when adding development dependency using git option without version specification + registers an offense when adding development dependency with tag specification + registers an offense when adding development dependency by parenthesized call with commit ref specification + registers an offense when adding development dependency with commit ref specification + registers an offense when adding development dependency by parenthesized call with version specification + does not register an offense when adding development dependency using git option by parenthesized call without version specification + registers an offense when adding development dependency with version specification + does not register an offense when adding development dependency without version specification + registers an offense when adding development dependency with branch specification + does not register an offense when adding development dependency by parenthesized call without version specification + registers an offense when adding development dependency by parenthesized call with tag specification + registers an offense when adding development dependency by parenthesized call with branch specification -RuboCop::Cop::Gemspec::DuplicatedAssignment - registers an offense when using `name=` twice - does not register an offense when `name=` method call is not block value - registers an offense when using `version=` twice - does not register an offense when using `spec.add_dependency` twice - does not register an offense when using `<<` twice - registers an offense when using `name=` twice with `cbase` - registers an offense when using `required_ruby_version=` twice +RuboCop::Cop::InternalAffairs::MethodNameEndWith + registers offense if there is potentially usage of `bang_method?` + registers an offense if there is potentially usage of `assignment_method?` + registers offense if there is potentially usage of `bang_method?` with safe navigation operator + does not register offense if argument for end_with? is some other string + registers offense if there is potentially usage of `predicate_method?` + registers an offense if `method_name` is a variable and there is potentially usage of `assignment_method?` + Ruby >= 2.7 + registers offense if argument for Symbol#end_with? is '!' with safe navigation operator + does not register offense if argument for Symbol#end_with? is some other string + registers offense if argument for Symbol#end_with? is '?' with safe navigation operator + registers an offense if method_name is symbol with safe navigation operator + registers offense if argument for Symbol#end_with? is '?' + registers offense if argument for Symbol#end_with? is '!' + registers an offense if method_name is symbol -RuboCop::Cop::Naming::FileName - with snake_case file names ending in .rb +RuboCop::Formatter::WorstOffendersFormatter + #finished + when there are many offenses + sorts by offense count first and then by cop name + +RuboCop::Cop::Lint::RedundantSplatExpansion + allows expanding a method call on an array literal + allows assigning a variable to a splat expansion of a variable + accepts expanding a variable as a method parameter + allows assigning to a splat + allows splat expansion inside of an array + allows assigning to an expanded range + allows an array using a constructor + allows expansions of an array that is assigned to a variable in rescue + registers an offense and corrects an array literal being expanded in a rescue + allows assigning to a splat variable + behaves like splat expansion + behaves like splat literal assignment + registers an offense and converts to an array + method parameters + registers an offense and converts to an array + expanding Array.new call on method argument + registers an offense and corrects + behaves like splat expansion + method parameters + registers an offense and converts to an array + behaves like splat literal assignment + registers an offense and converts to an array + expanding an array literal in a when condition + registers an offense and corrects an array using %W + registers an offense and corrects an array using [] + registers an offense and corrects %I to a list of symbols + allows an array that is assigned to a variable + registers an offense and corrects an array using %w + registers an offense and corrects %i to a list of symbols + allows an array using a constructor + expanding Array.new call on array literal + when the array literal contains more than one element + accepts + with ::Array.new + when the array literal contains exactly one element + registers an offense and corrects + when the array literal contains exactly one element + registers an offense and corrects + behaves like splat expansion + behaves like splat literal assignment + registers an offense and converts to an array + method parameters + registers an offense and converts to an array + splat expansion inside of an array + registers an offense and corrects the expansion of an array literalinside of an array literal + registers an offense and corrects expansion of %W to a list of words + registers an offense and corrects expansion of %w to a list of words + when `AllowPercentLiteralArrayArgument: true` + does not register an offense when using percent string literal array + does not register an offense when using percent symbol literal array + when `AllowPercentLiteralArrayArgument: false` + registers an offense when using percent literal array + registers an offense when using percent symbol literal array + behaves like array splat expansion + behaves like splat literal assignment + registers an offense and removes the splat from array + method parameters + registers an offense and converts to a list of arguments + behaves like array splat expansion + behaves like splat literal assignment + registers an offense and removes the splat from array + method parameters + registers an offense and converts to a list of arguments + splat expansion of method parameters + registers an offense and corrects an array literal %i + registers an offense and corrects an array literal %I + behaves like array splat expansion + method parameters + registers an offense and converts to a list of arguments + behaves like splat literal assignment + registers an offense and removes the splat from array + behaves like array splat expansion + method parameters + registers an offense and converts to a list of arguments + behaves like splat literal assignment + registers an offense and removes the splat from array + arrays being expanded with %i variants using splat expansion + splat expansion inside of an array + registers an offense and changes %I to a list of symbols + registers an offense and corrects %i to a list of symbols + behaves like splat expansion + behaves like splat literal assignment + registers an offense and converts to an array + method parameters + registers an offense and converts to an array + assignment to splat expansion + registers and corrects an array using top-level const + registers an offense and corrects an array using a constructor + behaves like array splat expansion + behaves like splat literal assignment + registers an offense and removes the splat from array + method parameters + registers an offense and converts to a list of arguments + +RuboCop::Cop::Naming::MethodParameterName + does not register offense for empty kwrestarg + registers offense when parameter contains uppercase characters + can register multiple offenses in one method definition + does not register offense for valid parameter names on self.method + does not register offense for valid parameter names + does not register for method without parameters + does not register offense for empty restarg + does not register offense for valid default parameters + registers offense when parameter ends in number + registers offense when parameter ends in number on class method + registers offense for offensive keyword parameters + registers offense when parameter is less than minimum length + registers offense for offensive default parameter + does not register offense for valid keyword parameters + registers offense when parameter with prefix is less than minimum length + with AllowNamesEndingInNumbers + accept parameters that end in numbers + with ForbiddenNames + accepts parameter that uses a forbidden name's letters + registers offense for parameter listed as forbidden + when using argument forwarding does not register an offense - with snake_case names which use ? and ! + with AllowedNames + registers unlisted offensive names + accepts specified block param names + accepts underscore param names + accepts param names prefixed with underscore + +RuboCop::Cop::Gemspec::OrderedDependencies + When using a local variable in an argument of dependent gem + does not register any offenses + When using method call to gem names + does not register any offenses + behaves like ordered dependency + when add_development_dependency + when each individual group of line is sorted + does not register any offenses + When gems are alphabetically sorted + does not register any offenses + when gems are not alphabetically sorted + registers an offense + when dependency is separated by multiline comment + with TreatCommentsAsGroupSeparators: true + accepts + with TreatCommentsAsGroupSeparators: false + registers an offense + behaves like ordered dependency + when add_runtime_dependency + When gems are alphabetically sorted + does not register any offenses + when each individual group of line is sorted + does not register any offenses + when dependency is separated by multiline comment + with TreatCommentsAsGroupSeparators: true + accepts + with TreatCommentsAsGroupSeparators: false + registers an offense + when gems are not alphabetically sorted + registers an offense + behaves like ordered dependency + when add_dependency + when dependency is separated by multiline comment + with TreatCommentsAsGroupSeparators: true + accepts + with TreatCommentsAsGroupSeparators: false + registers an offense + when gems are not alphabetically sorted + registers an offense + When gems are alphabetically sorted + does not register any offenses + when each individual group of line is sorted + does not register any offenses + when different dependencies are consecutive + does not register any offenses + +RuboCop::Cop::VisibilityHelp + #node_visibility + with inline private with symbol + is expected to eq :private + with visibility block private + is expected to eq :private + with visibility block private after public + is expected to eq :private + with visibility block public + is expected to eq :public + with inline private + is expected to eq :private + without visibility block + is expected to eq :public + with inline public + is expected to eq :public + +RuboCop::Cop::Style::ClassAndModuleChildren + compact style + registers an offense for classes with partially nested children + accepts nesting for classes with an explicit superclass + accepts nesting for classes/modules with more than one child + registers a offense for classes with nested children + accepts class/module with single method + registers a offense for modules with nested children + registers an offense for modules with partially nested children + accepts compact style for classes/modules + registers a offense for classes with nested one-liner children + correctly indents heavily nested children + preserves comments between classes + registers and offense for deeply nested children + nested style + accepts nested children + accepts cbase class name + registers an offense for not nested classes + registers an offense for not nested classes when namespace is defined as a class + registers an offense for partially nested classes + registers an offense for not nested modules + registers an offense for partially nested modules + registers an offense for not nested classes with explicit superclass + registers an offense for not nested classes when namespace is defined as a module + accepts :: in parent class on inheritance + accepts cbase module name + preserves comments + +RuboCop::Cop::Naming::FileName + with dotfiles does not register an offense - with snake_case file names with non-rb extension + with include acronym name does not register an offense + with camelCase file names without file extension + registers an offense with snake_case names which use + does not register an offense - with acronym class name + with snake_case file names ending in .rb does not register an offense - with camelCase file names without file extension - registers an offense with snake_case file names without file extension does not register an offense - with acronym namespace + with snake_case names which use ? and ! + does not register an offense + with non-snake-case file names with a shebang + does not register an offense + when IgnoreExecutableScripts is disabled + registers an offense + with snake_case file names with non-rb extension does not register an offense - with camelCase file names ending in .rb - registers an offense when the file is specified in AllCops/Include with a non-snake_case file name does not register an offense + with snake_case file names with multiple extensions + does not register an offense + with acronym namespace + does not register an offense + when Regex is set + with a non-matching name + registers an offense + with a matching name + does not register an offense + with camelCase file names ending in .rb + registers an offense + with acronym class name + does not register an offense + with non-ascii characters in filename + does not register an offense when ExpectMatchingDefinition is true - on a file which defines a Struct without a block - in a directory with multiple instances of test + on a file which defines multiple classes + in a matching directory under lib does not register an offense - in a matching directory under spec + in a directory elsewhere which only matches the module name does not register an offense - in a non-matching directory under spec - registers an offense in a non-matching directory under lib registers an offense + in a directory elsewhere which does not match the module name + registers an offense in a matching directory under test does not register an offense - in a directory with multiple instances of spec - does not register an offense - in a matching directory under src - does not register an offense - in a directory with multiple instances of src - does not register an offense - in a directory with multiple instances of lib - does not register an offense - in a non-matching directory under src + in a non-matching directory under spec registers an offense - in a directory elsewhere which does not match the module name + in a non-matching directory under src registers an offense - in a matching directory under lib + in a matching directory under src does not register an offense - in a directory elsewhere which only matches the module name + in a matching directory under spec does not register an offense - in a non-matching directory under test - registers an offense - on a file which defines a nested module - in a non-matching directory under lib - registers an offense in a directory with multiple instances of spec does not register an offense + in a directory with multiple instances of lib + does not register an offense + in a directory with multiple instances of test + does not register an offense in a directory with multiple instances of src does not register an offense in a non-matching directory under test registers an offense + on a file which defines a nested module in a non-matching directory under spec registers an offense - in a matching directory under src - does not register an offense in a matching directory under test does not register an offense - in a directory elsewhere which does not match the module name - registers an offense - in a matching directory under lib - does not register an offense - in a directory with multiple instances of test + in a matching directory under src does not register an offense - in a directory with multiple instances of lib + in a directory with multiple instances of src does not register an offense in a directory elsewhere which only matches the module name does not register an offense - in a matching directory under spec + in a directory with multiple instances of test does not register an offense - in a non-matching directory under src + in a directory elsewhere which does not match the module name + registers an offense + in a non-matching directory under test registers an offense - on a file which defines multiple classes in a matching directory under spec does not register an offense - in a directory with multiple instances of lib + in a non-matching directory under lib + registers an offense + in a matching directory under lib does not register an offense - in a directory with multiple instances of test + in a non-matching directory under src + registers an offense + in a directory with multiple instances of spec does not register an offense - in a matching directory under src + in a directory with multiple instances of lib does not register an offense + on a file which defines a nested class in a non-matching directory under test registers an offense in a non-matching directory under src registers an offense - in a non-matching directory under spec + in a directory with multiple instances of test + does not register an offense + in a matching directory under spec + does not register an offense + in a directory elsewhere which does not match the module name registers an offense + in a directory elsewhere which only matches the module name + does not register an offense in a non-matching directory under lib registers an offense in a directory with multiple instances of spec does not register an offense - in a directory with multiple instances of src + in a non-matching directory under spec + registers an offense + in a matching directory under src does not register an offense - in a directory elsewhere which only matches the module name + in a directory with multiple instances of src does not register an offense in a matching directory under test does not register an offense - in a directory elsewhere which does not match the module name - registers an offense + in a directory with multiple instances of lib + does not register an offense in a matching directory under lib does not register an offense - on a file which defines a Struct with a block + on a file which defines a Struct without a block in a matching directory under spec does not register an offense - in a directory with multiple instances of test - does not register an offense - in a matching directory under src - does not register an offense - in a non-matching directory under src - registers an offense in a non-matching directory under test registers an offense + in a directory with multiple instances of src + does not register an offense + in a directory with multiple instances of spec + does not register an offense in a non-matching directory under spec registers an offense - in a matching directory under test + in a directory with multiple instances of test does not register an offense - in a directory with multiple instances of src + in a matching directory under src does not register an offense in a non-matching directory under lib registers an offense + in a matching directory under test + does not register an offense + in a directory elsewhere which only matches the module name + does not register an offense in a directory elsewhere which does not match the module name registers an offense + in a non-matching directory under src + registers an offense + in a matching directory under lib + does not register an offense in a directory with multiple instances of lib does not register an offense + on a file which uses Name::Spaced::Module syntax + in a directory elsewhere which does not match the module name + registers an offense + in a directory with multiple instances of test + does not register an offense in a directory with multiple instances of spec does not register an offense - in a directory elsewhere which only matches the module name + in a non-matching directory under test + registers an offense + in a directory with multiple instances of src does not register an offense in a matching directory under lib does not register an offense - on a file which uses Name::Spaced::Module syntax - in a non-matching directory under spec - registers an offense - in a matching directory under test + in a matching directory under src does not register an offense - in a non-matching directory under test + in a non-matching directory under src registers an offense in a directory elsewhere which only matches the module name does not register an offense in a matching directory under spec does not register an offense - in a directory with multiple instances of test + in a non-matching directory under spec + registers an offense + in a non-matching directory under lib + registers an offense + in a matching directory under test does not register an offense in a directory with multiple instances of lib does not register an offense - in a non-matching directory under src - registers an offense - in a matching directory under src - does not register an offense + on a file which defines a Struct with a block in a directory elsewhere which does not match the module name registers an offense - in a non-matching directory under lib - registers an offense - in a directory with multiple instances of spec + in a matching directory under spec does not register an offense - in a directory with multiple instances of src + in a matching directory under src does not register an offense in a matching directory under lib does not register an offense - on a file which defines no class or module at all - under some other random directory - registers an offense - under lib - registers an offense - under src + in a matching directory under test + does not register an offense + in a directory elsewhere which only matches the module name + does not register an offense + in a non-matching directory under test registers an offense - under test + in a non-matching directory under spec registers an offense - under lib when not added to root + in a non-matching directory under src registers an offense - under spec + in a non-matching directory under lib registers an offense - on a file which defines a nested class - in a directory with multiple instances of test - does not register an offense in a directory with multiple instances of src does not register an offense - in a matching directory under spec + in a directory with multiple instances of test does not register an offense - in a directory with multiple instances of spec + in a directory with multiple instances of lib does not register an offense - in a directory elsewhere which only matches the module name + in a directory with multiple instances of spec does not register an offense - in a non-matching directory under lib + on a file which defines no class or module at all + under test registers an offense - in a non-matching directory under src + under lib when not added to root registers an offense - in a non-matching directory under spec + under lib registers an offense - in a matching directory under test - does not register an offense - in a directory elsewhere which does not match the module name + under src registers an offense - in a matching directory under src - does not register an offense - in a matching directory under lib - does not register an offense - in a non-matching directory under test + under spec + registers an offense + under some other random directory registers an offense - in a directory with multiple instances of lib - does not register an offense - on an empty file - registers an offense on an empty file with a space in its filename registers an offense - with include acronym name - does not register an offense - with dotfiles - does not register an offense - when Regex is set - with a matching name - does not register an offense - with a non-matching name + on an empty file registers an offense when CheckDefinitionPathHierarchy is false with a matching module containing a non-matching class @@ -15844,4741 +12280,2654 @@ does not register an offense with a matching module containing a non-matching struct does not register an offense - on a file with a non-matching class - registers an offense - on an empty file + on a file with a non-matching struct registers an offense on a file with a matching struct does not register an offense - with a non-matching module containing a matching struct - does not register an offense - with a non-matching module containing a matching class - does not register an offense - on a file with a non-matching struct + on a file with a non-matching class registers an offense on a file with a matching class does not register an offense - with non-ascii characters in filename - does not register an offense - with snake_case file names with multiple extensions - does not register an offense - with non-snake-case file names with a shebang - does not register an offense - when IgnoreExecutableScripts is disabled - registers an offense - -RuboCop::Cop::Lint::ScriptPermission - with file permission 0644 - registers an offense for script permission - if autocorrection is off - leaves the file intact - with stdin - skips investigation - with file permission 0755 - accepts with blank - accepts without shebang line - accepts with shebang line - -RuboCop::Cop::Style::TrailingCommaInArguments - with single line list of values - when EnforcedStyleForMultiline is no_comma - accepts heredoc without trailing comma - registers an offense for trailing comma in a method call - registers an offense for trailing comma preceded by whitespace in a method call - registers an offense for trailing comma in a method call with hash parameters at the end - accepts method call without trailing comma with single element hash parameters at the end - accepts method call without trailing comma - accepts method call without trailing comma when a line break before a method call - accepts chained single-line method calls - accepts method call without parameters - when using safe navigation operator - registers an offense for trailing comma in a method call with hash parameters at the end - registers an offense for trailing comma in a method call - when EnforcedStyleForMultiline is comma - accepts method call without trailing comma with single element hash parameters at the end - accepts heredoc without trailing comma - registers an offense for trailing comma in a method call with hash parameters at the end - accepts chained single-line method calls - registers an offense for trailing comma in a method call - registers an offense for trailing comma preceded by whitespace in a method call - accepts method call without trailing comma when a line break before a method call - accepts method call without trailing comma - accepts method call without parameters - when using safe navigation operator - registers an offense for trailing comma in a method call with hash parameters at the end - registers an offense for trailing comma in a method call - when EnforcedStyleForMultiline is consistent_comma - registers an offense for trailing comma preceded by whitespace in a method call - accepts method call without parameters - accepts method call without trailing comma with single element hash parameters at the end - accepts chained single-line method calls - registers an offense for trailing comma in a method call with hash parameters at the end - accepts heredoc without trailing comma - registers an offense for trailing comma in a method call - accepts method call without trailing comma - accepts method call without trailing comma when a line break before a method call - when using safe navigation operator - registers an offense for trailing comma in a method call - registers an offense for trailing comma in a method call with hash parameters at the end - with a single argument spanning multiple lines - when EnforcedStyleForMultiline is consistent_comma - accepts a single argument with no trailing comma - with multi-line list of values - when EnforcedStyleForMultiline is no_comma - autocorrects unwanted comma after modified heredoc parameter - accepts comma inside a heredoc with comments inside - accepts comma inside a heredoc in brackets - accepts a method call with hash parameters at the end and no trailing comma - accepts comma inside a heredoc with method and comments inside - accepts comma inside a heredoc parameter at the end - accepts comma inside a modified heredoc parameter - registers an offense for trailing comma in a method call with hash parameters at the end - when there is string interpolation inside heredoc parameter - autocorrects unwanted comma inside string interpolation - accepts comma inside a heredoc parameter when on a single line - accepts comma inside a heredoc parameter - when EnforcedStyleForMultiline is consistent_comma - accepts no trailing comma in a method call with a block parameter at the end - registers an offense for no trailing comma in a method call with hash parameters at the end - accepts a trailing comma in a method call with single line hashes - accepts trailing comma in a method call with hash parameters at the end - registers an offense for no trailing comma in a method call withtwo parameters on the same line - accepts a multiline call with a single argument and trailing comma - accepts a trailing comma in a method call with a single hash parameter to a receiver object - accepts a multiline call with arguments on a single line and trailing comma - autocorrects missing comma after a heredoc - accepts a trailing comma in a method call with a single hash parameter - accepts a multiline call with single argument on multiple lines - when closing bracket is on same line as last value - registers an offense for a method call, with a Hash as the last parameter, split on multiple lines - when EnforcedStyleForMultiline is comma - does not break when a safe method call is chained on the offending simple one - accepts a method call with two parameters on the same line - registers an offense for no trailing comma in a method call with hash parameters at the end - does not break when a method call is chained on the offending one - accepts an empty hash being passed as a method argument - accepts no trailing comma in a method call with a multiline braceless hash at the end with more than one parameter on a line - accepts trailing comma in a method call with hash parameters at the end - accepts missing comma after heredoc with comments - does not break when a safe method call is chained on the offending more complex one - accepts a trailing comma in a method call with single line hashes - accepts a multiline call with a single argument and trailing comma - when closing bracket is on same line as last value - accepts a method call with Hash as last parameter split on multiple lines - with a single argument of anonymous function spanning multiple lines - when EnforcedStyleForMultiline is consistent_comma - accepts a single argument with no trailing comma - -RuboCop::Cop::Layout::RescueEnsureAlignment - accepts aligned rescue in do-end block assigned to class - accepts correctly aligned ensure - accepts correctly aligned rescue in assigned begin-end block - accepts aligned rescue in do-end block with `.()` call - accepts correctly aligned rescue/ensure with def - accepts aligned rescue in do-end block assigned to global variable - accepts aligned rescue with do-end block that line break with trailing dot for method calls - accepts aligned rescue in do-end block - accepts aligned rescue in do-end block assigned to instance variable - accepts aligned rescue in do-end block on and-assignment - accepts aligned rescue in do-end block assigned to class variable - accepts aligned rescue in assigned do-end block starting on newline - accepts correctly aligned rescue/ensure with def with no body - accepts correctly aligned rescue - accepts aligned rescue in do-end block on multi-assignment - accepts end being misaligned - accepts aligned rescue in do-end block on or-assignment - accepts aligned rescue in do-end block in a method - accepts the modifier form - accepts aligned rescue do-end block assigned to local variable - accepts aligned rescue with do-end block that line break with leading dot for method calls - accepts aligned rescue in do-end block on operation assignment - accepts rescue and ensure on the same line - rescue with defs - registers an offense - allows inline expression before - rescue - registers an offense - ensure + on an empty file registers an offense - rescue in do-end block assigned to local variable - registers an offense - ensure with defs - registers an offense - allows inline access modifier - with private_class_method modifier - ensure with def - registers an offense - correct alignment - rescue with def - registers an offense - correct alignment - rescue with defs - correct alignment - registers an offense - ensure with defs - registers an offense - correct alignment - with private modifier - ensure with defs - correct alignment - registers an offense - ensure with def - registers an offense - correct alignment - rescue with def - correct alignment - registers an offense - rescue with defs - registers an offense - correct alignment - with public_class_method modifier - ensure with defs - correct alignment - registers an offense - rescue with def - registers an offense - correct alignment - ensure with def - registers an offense - correct alignment - rescue with defs - correct alignment - registers an offense - rescue in do-end block on operation assignment - registers an offense - rescue in do-end block on multi-assignment - registers an offense - rescue with class - registers an offense when rescue used with class - rescue with def - registers an offense - rescue in do-end block assigned to global variable - registers an offense - rescue in assigned do-end block starting on newline - registers an offense - ensure with def - registers an offense - when using zsuper with block - registers and corrects an offense and corrects when incorrect alignment - does not register an offense when correct alignment - ensure with begin - registers an offense when ensure used with begin - rescue in do-end block assigned to class variable - registers an offense - ensure with module - registers an offense when ensure used with module - rescue with module - registers an offense when rescue used with module - rescue in do-end block assigned to instance variable - registers an offense - rescue with begin - registers an offense - as RHS of assignment - when `EnforcedStyleAlignWith: start_of_line` of `Layout/BeginEndAlignment` cop - accepts multi-line, aligned - registers an offense and corrects for incorrect alignment - accepts multi-line, indented - `Layout/BeginEndAlignment` cop is not enabled - registers an offense and corrects for incorrect alignment - accepts multi-line, aligned - accepts multi-line, indented - when `EnforcedStyleAlignWith: begin` of `Layout/BeginEndAlignment` cop - registers an offense and corrects for incorrect alignment - accepts multi-line, indented - accepts multi-line, aligned - ensure with class - registers an offense - rescue with do-end block - registers an offense - excluded file - processes excluded files with issue - rescue in do-end block assigned to class - registers an offense - rescue in do-end block on or-assignment - registers an offense - rescue in do-end block on and-assignment - registers an offense - -RuboCop::Cop::Layout::SpaceInsideStringInterpolation - when EnforcedStyle is no_space - accepts empty interpolation - does not touch spaces inside the interpolated expression - for well-formatted string interpolations - accepts excess literal spacing - for ill-formatted string interpolations - finds interpolations in string-like contexts - registers offenses and autocorrects - when interpolation starts or ends with a line break - ignores comments and whitespace when looking for line breaks + with a non-matching module containing a matching struct + does not register an offense + with a non-matching module containing a matching class does not register an offense - for "space" style formatted string interpolations - registers offenses and autocorrects - when EnforcedStyle is space - accepts empty interpolation - for ill-formatted string interpolations - registers offenses and autocorrects - for "no_space" style formatted string interpolations - registers offenses and autocorrects - for well-formatted string interpolations - does not register an offense for excess literal spacing - -RuboCop::Cop::Style::MultilineInPatternThen - >= Ruby 2.7 - doesn't register an offense for multiline `in` statement with `then` followed by other lines - registers an offense for empty `in` statement with `then` - does not register an offense for array `when` statement with `then` - doesn't register an offense for singleline `in` statement with `then` - registers an offense for multiline (one line in a body) `in` statement with `then` - doesn't register an offense when `then` required for a body of `in` is used - does not register an offense when line break for multiple candidate values of `in` - autocorrects when the body of `in` branch starts with `then` - does not register an offense for hash `in` statement with `then` - doesn't register an offense for multiline `in` statement without `then` - registers an offense for multiline (two lines in a body) `in` statement with `then` - doesn't register an offense for empty `in` statement without `then` - registers an offense when one line for multiple candidate values of `in` - -RuboCop::Cop::Layout::ArgumentAlignment - aligned with fixed indentation - autocorrects by outdenting when indented too far - autocorrects by indenting when not indented - corrects indentation for kwargs starting on same line as other args - autocorrects when first line is indented - registers an offense and corrects when missed indentation kwargs - does not register an offense when using aligned braced hash as a argument - multi-line method calls - registers offenses and corrects double indentation from relevant method - autocorrects relative to position of relevant method call - can handle existing indentation from multi-line method calls - does not err on method call without a method name - assigned methods - with IndentationWidth:Width set to 4 - accepts the first parameter being on a new row - accepts the first parameter being on method row - autocorrects even when first argument is in wrong position - with ArgumentAlignment:IndentationWidth set to 4 - accepts the first parameter being on a new row - accepts the first parameter being on method row - aligned with first argument - can handle parentheses used with no arguments - doesn't get confused by regexen with embedded expressions - can handle heredoc strings - can handle other method calls without parentheses - doesn't get confused by symbols with embedded expressions - doesn't get confused by a symbol argument - accepts multiline []= method call - can handle a method call within a method call - can handle a call with a block inside another call - doesn't get confused by extra comma at the end - does not crash in autocorrect on dynamic string in parameter value - can handle a call embedded in a string - accepts correctly aligned arguments with fullwidth characters - doesn't crash and burn when there are nested issues - registers an offense and corrects multiline missed indentation - accepts correctly aligned arguments - doesn't get confused by a line break inside a parameter - can handle do-end - registers an offense and corrects when missed indentation kwargs - can handle a multiline hash as second parameter - registers an offense and corrects multi-line outdented parameters - registers an offense and corrects splat operator - can handle a ternary condition with a block reference - registers an offense and corrects arguments with double indent - can handle method calls without parentheses - registers an offense and corrects arguments with single indent - registers an offense and correct multi-line parametersindented too far - accepts braceless hashes - accepts the first parameter being on a new row - accepts calls that only span one line - can handle a correctly aligned string literal as first argument - can handle a string literal as other argument - when using safe navigation operator - registers an offense and corrects arguments with single indent - assigned methods - accepts the first parameter being on a new row - accepts the first parameter being on method row - -RuboCop::Cop::Layout::MultilineMethodCallIndentation - when EnforcedStyle is indented - accepts normal indentation of method parameters - registers an offense and corrects one space indentation of 2nd line - accepts any indentation of parameters to #[] - accepts indentation relative to first receiver - accepts indented methods in LHS of []= assignment - accepts alignment inside a grouped expression - accepts indented methods in ordinary statement - accepts indentation of assignment to obj.a with newline after = - accepts correctly indented methods in operation - registers an offense for a 2 space indentation of until condition - accepts an expression where the first method spans multiple lines - accepts special indentation of return if condition - accepts any indentation of method parameters - doesn't crash on unaligned multiline lambdas - accepts indentation of assignment to a with newline after = - doesn't fail on unary operators - accepts double indentation of unless condition - accepts indentation of assignment to a with rhs on same line - registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array - registers an offense and corrects 1 space indentation of 3rd line - accepts indented methods in until body - accepts indentation of assignment to obj.a[:key] with newline after = - accepts indented methods in while body - registers an offense and corrects 0 space indentation inside square brackets - accepts indentation of assignment to a[:key] with rhs on same line - accepts special indentation of return unless condition - accepts double indentation of while condition - registers an offense and corrects extra indentation of 3rd line in typical RSpec code - accepts double indentation of until condition - accepts even indentation of consecutive lines in typical RSpec code - accepts normal indentation inside grouped expression - accepts no extra indentation of third line - accepts indented methods in if body - registers an offense for a 2 space indentation of unless condition - registers an offense and corrects wrong indentation of for expression - registers an offense and corrects proc call without a selector - registers an offense and corrects aligned operators in assignment - registers an offense and corrects aligned methods in if condition - accepts alignment of method with assignment and operator-like method - accepts indentation of assignment to a[:key] with newline after = - accepts indented methods in unless body - accepts indented methods in if condition - accepts indented methods inside and outside a block - accepts special indentation of for expression - registers an offense and corrects correct + unrecognized style - registers an offense and corrects 3 spaces indentation of 2nd line - registers an offense and corrects no indentation of second line - registers an offense for a 2 space indentation of if condition - registers an offense for a 2 space indentation of while condition - accepts double indentation of if condition - accepts indented methods in for body - registers an offense and corrects extra indentation of third line - for possible semantic alignment - accepts indented methods - when indentation width is overridden for this cop - accepts indented methods in if condition - accepts indented methods in while body - registers an offense for a 4 space indentation of while condition - accepts indented methods in if body - registers an offense for a 4 space indentation of until condition - registers an offense for a 4 space indentation of if condition - accepts indentation of while condition which is offset by a single normal indentation step - accepts indented methods in until body - accepts indented methods - accepts indentation of until condition which is offset by a single normal indentation step - accepts indented methods in unless body - accepts indentation of unless condition which is offset by a single normal indentation step - accepts indentation of assignment - accepts correctly indented methods in operation - accepts indentation of if condition which is offset by a single normal indentation step - registers an offense for a 4 space indentation of unless condition - when EnforcedStyle is aligned - accepts no extra indentation of third line - accepts even indentation of consecutive lines in typical RSpec code - accepts aligned methods in constant assignment - accepts aligned method in return - accepts alignment of method with assignment and operator-like method - accepts indentation relative to first receiver - registers an offense and corrects misaligned methods in if condition - does not check binary operations when string wrapped with backslash - registers an offense and corrects misaligned methods in unless condition - accepts an expression where the first method spans multiple lines - accepts aligned method in assignment + block + assignment - registers an offense and corrects 3 spaces indentation of 2nd line - registers an offense and corrects misaligned methods in until condition - registers an offense and corrects no indentation of second line - registers an offense and corrects misaligned methods in local variable assignment - accepts correctly aligned methods in assignment - registers an offense and corrects one space indentation of 3rd line - registers an offense and corrects extra indentation of 3rd line in typical RSpec code - accepts indented methods in for body - accepts aligned methods in if + assignment - doesn't fail on unary operators - accepts aligned methods in a begin..end block - registers an offense and corrects misaligned method in []= call - doesn't crash on unaligned multiline lambdas - does not check binary operations when string wrapped with + - registers an offense and corrects proc call without a selector - registers an offense and corrects unaligned methods in assignment - accepts aligned methods in if condition - registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array - accepts indented methods in ordinary statement - accepts indented and aligned methods in binary operation - accepts indented method when there is nothing to align with - registers an offense and corrects extra indentation of third line - registers an offense and corrects one space indentation of 2nd line - accepts indented methods in LHS of []= assignment - registers an offense and corrects misaligned methods in while condition - accepts indented methods inside and outside a block - accepts any indentation of parameters to #[] - accepts alignment inside a grouped expression - accepts correctly aligned methods in operands - accepts aligned methods in assignment - accepts aligned methods in operator assignment - for semantic alignment - accepts methods being aligned with method that is an argument - doesn't fail on a chain of aref calls - accepts aligned method even when an aref is first in the chain - accepts nested method calls - accepts aligned method even when an aref is in the chain - accepts methods being aligned with method that is an argument in assignment - registers an offense and corrects unaligned methods - accepts key access to hash - accepts 3 aligned methods - accepts method being aligned with method - accepts method being aligned with method in assignment - accepts aligned method with blocks in operation assignment - registers an offense and corrects unaligned method in block body - >= Ruby 2.7 - accepts methods being aligned with method that is an argumentwhen using numbered parameter - when EnforcedStyle is indented_relative_to_receiver - registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array - registers an offense and corrects no indentation of second line - registers an offense and corrects 3 spaces indentation of second line - doesn't fail on unary operators - doesn't crash on unaligned multiline lambdas - registers an offense and corrects extra indentation of 3rd line - does not register an offense when multiline method chain has expected indent width and the method is preceded by double splat - accepts indentation of consecutive lines in typical RSpec code - registers an offense and corrects proc call without a selector - accepts indented methods in for body - accepts correctly indented methods in operation - does not register an offense when multiline method chain has expected indent width and the method is preceded by splat - accepts indented methods inside and outside a block - accepts any indentation of parameters to #[] - accepts indented methods in LHS of []= assignment - accepts alignment inside a grouped expression - registers an offense and corrects extra indentation of 3rd line in typical RSpec code - accepts no extra indentation of third line - accepts alignment of method with assignment and operator-like method - accepts an expression where the first method spans multiple lines - registers an offense and corrects one space indentation of 2nd line - accepts indentation relative to first receiver - accepts indented methods in ordinary statement - for possible semantic alignment - accepts indented methods - -RuboCop::Cop::Layout::FirstHashElementIndentation - when the HashAlignment style is separator for : - registers an offense and corrects incorrectly indented first pair with : - registers an offense and corrects incorrectly indented } - accepts correctly indented first pair - when hash is argument to setter - registers an offense and corrects incorrectly indented first pair - accepts correctly indented first pair - when hash is method argument - and arguments are surrounded by parentheses - and EnforcedStyle is special_inside_parentheses - accepts special indentation for first argument - accepts normal indentation for hash within hash - accepts special indentation for second argument - registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key - accepts indent based on the left brace when the outer hash key and the left brace is not on the same line - registers an offense and corrects 'consistent' indentation - registers an offense and corrects 'align_braces' indentation - accepts indent based on the preceding left parenthesiswhen the right brace and its following pair is on the same line - registers an offense for incorrectly indented hash that is the value of a single pair hash - when using safe navigation operator - registers an offense and corrects 'consistent' indentation - and EnforcedStyle is consistent - accepts normal indentation for second argument - accepts indent based on the left brace when the outer hash key and the left brace is not on the same line - registers an offense for incorrectly indented hash that is the value of a single pair hash - accepts indent based on the start of the line where the left brace iswhen the right brace and its following pair is on the same line - registers an offense and corrects incorrect indentation - registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key - accepts normal indentation for first argument - and argument are not surrounded by parentheses - registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key - accepts indent based on the left brace when the outer hash key and the left brace is not on the same line - registers an offense for incorrectly indented multi-line hash with braces - registers an offense for the first inner hash member not based on the start of line when the outer hash pair has no following siblings - accepts indent based on the start of the line where the left brace iswhen the right brace and its following pair is on the same line - accepts braceless hash - accepts a correctly indented multi-line hash with braces - accepts single line hash with braces - when hash is right hand side in assignment - accepts an empty hash - accepts correctly indented first pair - accepts several pairs per line - accepts a first pair on the same line as the left brace - registers an offense and corrects incorrectly indented first pair - accepts single line hash - when indentation width is overridden for this cop - accepts correctly indented first pair - registers an offense and corrects incorrectly indented first pair - when hash is operand - accepts correctly indented first pair - registers an offense and corrects incorrectly indented first pair - registers an offense and corrects incorrectly indented } - when EnforcedStyle is align_braces - registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key - accepts a first pair on the same line as the left brace - registers an offense and corrects incorrectly indented } - accepts several pairs per line - accepts single line hash - accepts an empty hash - accepts correctly indented first pair - registers an offense for incorrectly indented hash that is the value of a single pair hash - when 'consistent' style is used - registers an offense and corrects incorrect indentation - when 'special_inside_parentheses' style is used - registers an offense and corrects incorrect indentation - when the HashAlignment style is separator for => - accepts correctly indented first pair - registers an offense and corrects incorrectly indented } - registers an offense and corrects incorrectly indented first pair with => -RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor - registers an offense and corrects for some attribute accessors and comment line - registers an offense and corrects for an attribute accessor and some comment line - accepts code that separates attribute accessors from the code with a newline - does not register an offense and corrects when using `if` ... `else` branches - registers an offense and corrects for an attribute accessor and comment line - registers an offense and corrects for an attribute accessor and `rubocop:enable` comment line - registers an offense and corrects for code that immediately follows accessor - accepts code that separates attribute accessors from the code and comment line with a newline - accepts code that separates an attribute accessor from the code and `rubocop:enable` comment line with a newline - accepts code that separates an attribute accessor from the code with a newline - accepts code that where the attr_accessor is the last line - registers an offense and corrects for an attribute accessor and `rubocop:disable` comment line - accepts code when attribute method is method chained - accepts code when used in class definition - registers an offense and corrects for code that immediately follows accessor with comment - registers an offense and corrects for an attribute accessor and `rubocop:enable` comment line and other comment - when `AllowAliasSyntax: true` - does not register an offense for code that immediately `alias` syntax after accessor - when `AllowedMethods: []` - registers an offense for code that immediately ignored methods after accessor - when `AllowAliasSyntax: false` - registers an offense for code that immediately `alias` syntax after accessor - when `AllowedMethods: private` - does not register an offense for code that immediately ignored methods after accessor +RuboCop::Cop::Layout::CommentIndentation + when allow_for_alignment is true + accepts comments with extra indentation if aligned with comment on previous line + registers an offense and corrects + registers offenses and corrects before __END__ but not after + on outer level + registers an offense and corrects a documentation comment + registers an offense and corrects an incorrectly indented (1) comment + accepts a correctly indented comment + accepts a comment that follows code + registers an offense and corrects an incorrectly indented (2) comment + registers an offense for each incorrectly indented comment + around program structure keywords + accepts correctly indented comments + with a blank line following the comment + accepts a correctly indented comment + near various kinds of brackets + is unaffected by closing bracket that does not begin a line + accepts correctly indented comments + when allow_for_alignment is false + registers an offense and corrects + registers an offense for comments with extra indentation + registers offenses and corrects before __END__ but not after + near various kinds of brackets + is unaffected by closing bracket that does not begin a line + accepts correctly indented comments + on outer level + accepts a comment that follows code + registers an offense and corrects an incorrectly indented (2) comment + registers an offense for each incorrectly indented comment + registers an offense and corrects an incorrectly indented (1) comment + accepts a correctly indented comment + registers an offense and corrects a documentation comment + around program structure keywords + accepts correctly indented comments + with a blank line following the comment + accepts a correctly indented comment -RuboCop::Cop::Style::CollectionCompact - registers an offense and corrects when using `reject` on array to reject nils - registers an offense and corrects when using `reject` with block pass arg and no parentheses - does not register an offense when using `reject` to not to rejecting nils - registers an offense and corrects when using `reject` with block pass arg on array to reject nils - registers an offense and corrects when using `select/select!` to reject nils - registers an offense and corrects when using `reject` and receiver is a variable - does not register an offense when using `compact/compact!` - registers an offense and corrects when using `reject` on hash to reject nils - Ruby >= 3.1 - registers an offense and corrects when using `to_enum.reject` on array to reject nils - registers an offense and corrects when using `lazy.reject` on array to reject nils - when without receiver - does not register an offense and corrects when using `reject` on array to reject nils - does not register an offense and corrects when using `select/select!` to reject nils - Ruby <= 3.0 - does not register an offense and corrects when using `to_enum.reject` on array to reject nils - does not register an offense and corrects when using `lazy.reject` on array to reject nils +RuboCop::Cop::Style::WhenThen + accepts ; separating statements in the body of when + registers an offense for when b; + registers an offense for when b, c; + when inspecting a case statement with an empty branch + does not register an offense -RuboCop::Cop::Metrics::Utils::AbcSizeCalculator - #calculate - with unused assignments - is expected to eq "<2, 1, 0>" - when discounting repeated calls - when root receiver is self/nil - is expected to eq "<2, 9, 1>" - when some calls have arguments - is expected to eq "<1, 7, 0>" - when root receiver is a var - is expected to eq "<3, 9, 0>" - multiple assignment with method setters - is expected to eq "<3, 5, 0>" - when counting repeated calls - is expected to eq "<1, 4, 0>" - equivalent to multiple assignment with method setters - is expected to eq "<3, 5, 0>" - elsif vs else if - elsif - is expected to eq "<0, 5, 3>" - else if - is expected to eq "<0, 5, 4>" - with ||= on a constant - is expected to eq "<1, 0, 1>" - method with arguments - is expected to eq "<4, 0, 0>" - assignment with ternary operator - is expected to eq "<2, 6, 2>" - with a known iterating block - is expected to eq "<2, 4, 2>" - multiple calls with return - is expected to eq "<0, 3, 0>" - with += - is expected to eq "<2, 0, 0>" - with a block - is expected to eq "<2, 3, 0>" - with a yield - is expected to eq "<0, 1, 0>" - with &&= - is expected to eq "<2, 0, 1>" - same but with 7 arguments - is expected to eq "<9, 3, 0>" - with .foo = - is expected to eq "<1, 2, 0>" - with &.foo - is expected to eq "<0, 4, 2>" - with repeated lvar receivers - is expected to eq "<3, 5, 3>" - with a for - is expected to eq "<2, 1, 1>" - same with extra condition - is expected to eq "<2, 9, 5>" - if and arithmetic operations - is expected to eq "<2, 8, 4>" - with []= - is expected to eq "<2, 1, 0>" - multiple assignment - is expected to eq "<3, 1, 0>" - with ||= - is expected to eq "<2, 0, 1>" - with += for setters - is expected to eq "<1, 2, 0>" +RuboCop::Cop::Style::NestedTernaryOperator + registers an offense and corrects for a nested ternary operator expression + registers an offense and corrects for a nested ternary operator expression with no parentheses on the outside + can handle multiple nested ternaries + registers an offense and corrects for a nested ternary operator expression with block + accepts a non-nested ternary operator within an if -RuboCop::Cop::Layout::SpaceBeforeBlockBraces - when EnforcedStyle is space - registers an offense and corrects multiline block where the left brace has no outer space - accepts braces surrounded by spaces - registers an offense and corrects left brace without outer space - registers an offense and corrects opposite + correct style - Ruby 2.7 - registers an offense and corrects multiline block where the left brace has no outer space - registers an offense and corrects opposite + correct style - with space before empty braces not allowed - accepts empty braces without outer space - registers an offense and corrects empty braces - with space before empty braces allowed - registers an offense and corrects empty braces - accepts empty braces with outer space - when EnforcedStyle is no_space - registers an offense and corrects braces surrounded by spaces - registers an offense and corrects correct + opposite style - accepts left brace without outer space - Ruby 2.7 - registers an offense and corrects correct + opposite style - with `EnforcedStyle` of `Style/BlockDelimiters` - accepts left brace without outer space - with invalid value for EnforcedStyleForEmptyBraces - fails with an error +RuboCop::Cop::Util + #same_line? + returns true when two nodes are on the same line + returns false when two nodes are not on the same line + returns false if an argument is not a node or range + can use ranges + #to_supported_styles + when EnforcedStyle + is expected to eq "SupportedStyles" + when EnforcedStyleInsidePipes + is expected to eq "SupportedStylesInsidePipes" + #line_range + returns line range of the expression -RuboCop::Cop::Naming::InclusiveLanguage - symbols - when CheckSymbols is true - registers an offense - when CheckSymbols is false - does not register an offense - strings - does not register offenses and not raise `ArgumentError` for invalid byte sequence in UTF-8 - registers an offense for an interpolated string - registers an offense for a multiline string - registers an offense in a heredoc - when CheckStrings config is false - does not register offenses for strings - constants - when CheckConstants config is true - registers offenses for constants - when CheckConstants config is false - does not register offenses for constants - filepath - CheckFilepaths is false - does not register an offense - multiple offenses in filename - registers an offense with all problematic words - one offense in filename - registers an offense - offense in directory name - registers an offense for a director - suggestions - flagged term with two suggestions - includes both suggestions in the offense message - flagged term with three or more suggestions - includes all suggestions in the message - flagged term with one suggestion - includes the suggestion in the offense message - identifiers - when CheckIdentifiers config is false - does not register offenses for identifiers - when CheckIdentifiers config is true - registers an offense - allowed use - does not register an offense for an allowed use - offense after an allowed use - registers an offense at the correct location - variables - when CheckVariables config is true - registers offenses for global variables - registers offenses for class variables - registers offenses for instance variables - when CheckVariables config is false - does not register offenses for variables - flagged term matching - registers an offense when using a flagged term - registers an offense when using a flagged term with mixed case - registers an offense for a partial word match - regex - registers an offense for a flagged term matched with a regexp - multiple offenses on a line - registers an offense for each word - WholeWord: true - only flags when the term is a whole word - disable default flagged term - ignores flagged terms that are set to nil - comments - registers an offense in a single line comment - registers an offense in a block comment - when CheckComments is false - does not register an offense +RuboCop::Cop::Metrics::PerceivedComplexity + when AllowedPatterns is enabled + does not register an offense when defining an instance method + does not register an offense when defining a class method + does not register an offense when using `define_method` + when AllowedMethods is enabled + does not register an offense when defining a class method + does not register an offense when defining an instance method + does not register an offense when using `define_method` + when Max is 1 + registers an offense for a rescue block + registers an offense for an unless modifier + registers an offense for && + counts known iterating block + accepts complex code outside of methods + deals with nested if blocks containing && and || + accepts a method with no decision points + registers an offense for a case/when block + registers an offense for a for block + registers an offense for an until block + registers an offense for a ternary operator + registers an offense for elsif and else blocks + registers an offense for an if modifier + registers an offense for and + registers an offense for a while block + accepts an empty method + counts else in a case with no argument + counts only a single method + registers an offense for || + does not count unknown block calls + accepts an empty `define_method` + registers an offense for a case/when block without an expression after case + registers an offense for a `define_method` + registers an offense for or + when Max is 2 + counts stupid nested if and else blocks -RuboCop::Cop::Style::EndlessMethod - Ruby >= 3.0 - EnforcedStyle: disallow - registers an offense for an endless method with arguments - registers an offense for an endless method - EnforcedStyle: allow_always - does not register an offense for a multiline endless method with arguments - does not register an offense for a multiline endless method - does not register an offense for an endless method with arguments - does not register an offense for an endless method - does not register an offense for a multiline endless method with begin - EnforcedStyle: allow_single_line - registers an offense and corrects for a multiline endless method with arguments - does not register an offense for an endless method - does not register an offense for an endless method with arguments - registers an offense and corrects for a multiline endless method - registers an offense and corrects for a multiline endless method with begin +RuboCop::RemoteConfig + .inherit_from_remote + when the remote includes file starting with `./` + returns remote includes URI + .file + downloads the file if the file does not exist + downloads the file if cache lifetime has been reached + does not download the file if cache lifetime has not been reached + when the remote URL responds with not modified + reuses the existing cached file + when remote URL is configured with token auth + does not download the file if cache lifetime has not been reached + downloads the file if the file does not exist + downloads the file if cache lifetime has been reached + when the remote URL responds with 404 + raises error + when the network is inaccessible + reuses the existing cached file + when the remote URL responds with 500 + raises error + when remote URL is configured with basic auth + downloads the file if cache lifetime has been reached + does not download the file if cache lifetime has not been reached + downloads the file if the file does not exist + when the remote URL responds with 500 + raises error + when the remote URL responds with 404 + raises error + when the remote URL responds with redirect + follows the redirect and downloads the file RuboCop::Cop::Style::Sample behaves like accepts - accepts shuffle.slice(foo, bar) - behaves like offense - registers an offense for shuffle(random: foo).last(bar) + accepts shuffle(random: Random.new)[2] behaves like accepts - accepts shuffle[3, 3] + accepts shuffle.slice(3, 3) behaves like offense - registers an offense for shuffle(random: Random.new)[0..3] + registers an offense for shuffle(random: foo).last(bar) behaves like offense - registers an offense for shuffle[-1] + registers an offense for shuffle.first behaves like offense registers an offense for shuffle[0] - behaves like accepts - accepts shuffle.map { |e| e } behaves like offense - registers an offense for shuffle.first + registers an offense for shuffle.first(foo) behaves like offense - registers an offense for shuffle[0, 3] - behaves like accepts - accepts shuffle.slice(foo..3) + registers an offense for shuffle.last(3) behaves like accepts - accepts shuffle[foo, 3] - behaves like offense - registers an offense for shuffle.first(2) + accepts shuffle(random: Random.new)[2, 3] behaves like accepts - accepts shuffle.at(2) + accepts shuffle.slice(foo, 3) behaves like accepts - accepts shuffle.at(foo) + accepts shuffle.slice(-4..-3) behaves like accepts - accepts shuffle[-4..-3] - behaves like offense - registers an offense for shuffle.first(foo) - behaves like offense - registers an offense for shuffle(random: Random.new).first(2) + accepts shuffle behaves like offense - registers an offense for shuffle.last - behaves like accepts - accepts shuffle.join([5, 6, 7]) + registers an offense for shuffle.slice(0, 3) behaves like offense registers an offense for shuffle.at(-1) behaves like offense - registers an offense for shuffle.slice(0..3) - behaves like accepts - accepts shuffle[2] + registers an offense for shuffle.slice(0...3) + Ruby >= 2.6 + behaves like accepts + accepts shuffle[3..] + behaves like accepts + accepts shuffle[3...] + behaves like offense + registers an offense for shuffle[-1] behaves like offense registers an offense for shuffle.last(bar) behaves like accepts - accepts shuffle[foo] - behaves like offense - registers an offense for shuffle(random: Random.new).first + accepts sample behaves like accepts - accepts shuffle[2..3] - behaves like offense - registers an offense for shuffle[0..3] + accepts shuffle.slice(foo..3) behaves like accepts - accepts shuffle[2..-3] + accepts shuffle[2] + behaves like accepts + accepts shuffle(random: Random.new).find(&:odd?) behaves like offense registers an offense for shuffle.at(0) - behaves like accepts - accepts shuffle.slice(-4..-3) - behaves like accepts - accepts shuffle.slice(2..-3) - behaves like accepts - accepts shuffle.slice(foo..bar) behaves like offense - registers an offense for shuffle.slice(-1) + registers an offense for shuffle.first(2) behaves like accepts - accepts shuffle[foo..bar] - behaves like offense - registers an offense for shuffle.slice(0...3) + accepts shuffle.at(foo) behaves like accepts - accepts shuffle(random: Random.new).find(&:odd?) - behaves like offense - registers an offense for shuffle.slice(0) + accepts shuffle[3, 3] behaves like accepts - accepts shuffle.slice(foo) + accepts shuffle[2..-3] + behaves like accepts + accepts shuffle.slice(2) behaves like offense registers an offense for shuffle[0...3] - behaves like offense - registers an offense for shuffle.slice(0, 3) behaves like accepts - accepts sample + accepts shuffle[foo..bar] behaves like accepts - accepts shuffle + accepts shuffle.at(2) behaves like accepts - accepts shuffle.slice(3, 3) + accepts shuffle.slice(2..3) behaves like accepts accepts shuffle[foo, bar] - behaves like offense - registers an offense for shuffle.last(3) - behaves like accepts - accepts shuffle.slice(2) behaves like accepts - accepts shuffle.slice(foo, 3) + accepts shuffle.slice(foo..bar) behaves like accepts accepts shuffle[foo..3] + behaves like offense + registers an offense for shuffle[0, 3] + behaves like offense + registers an offense for shuffle.last + behaves like offense + registers an offense for shuffle.slice(-1) behaves like accepts - accepts shuffle(random: Random.new)[2] + accepts shuffle.slice(foo, bar) behaves like accepts accepts shuffle(random: Random.new) + behaves like accepts + accepts shuffle.join([5, 6, 7]) + behaves like accepts + accepts shuffle.slice(foo) Ruby >= 2.7 behaves like offense registers an offense for shuffle[...3] behaves like accepts - accepts shuffle.slice(2..3) - Ruby >= 2.6 - behaves like accepts - accepts shuffle[3...] - behaves like accepts - accepts shuffle[3..] + accepts shuffle[-4..-3] + behaves like offense + registers an offense for shuffle(random: Random.new)[0..3] + behaves like offense + registers an offense for shuffle(random: Random.new).first(2) behaves like accepts - accepts shuffle(random: Random.new)[2, 3] + accepts shuffle[foo, 3] + behaves like accepts + accepts shuffle[2..3] + behaves like offense + registers an offense for shuffle.slice(0..3) + behaves like accepts + accepts shuffle[foo] + behaves like offense + registers an offense for shuffle.slice(0) + behaves like offense + registers an offense for shuffle[0..3] + behaves like accepts + accepts shuffle.slice(2..-3) + behaves like accepts + accepts shuffle.map { |e| e } + behaves like offense + registers an offense for shuffle(random: Random.new).first -RuboCop::Cop::Style::YodaCondition - enforce not yoda - registers an offense number on left - accepts array of numbers on both sides - registers an offense number on left of comparison - accepts assignment - accepts global variable on left - accepts number on both sides - accepts interpolated regex on left - accepts string literal on left of case equality check - accepts number on left of <=> - accepts variable on left after assign - accepts instance variable on left - registers an offense for nil on left - accepts __FILE__ on left in negated program name check - accepts string literal on right - accepts method call on receiver on left - accepts negation - accepts class variable on left - accepts subtraction expression on left of comparison - registers an offense for boolean literal on left - registers an offense for string literal on left - accepts interpolated string on left - accepts accessor and variable on left in boolean expression - accepts __FILE__ on left in program name check - accepts safe navigation on left - within an if or ternary statement - registers an offense for number on left in if condition - registers an offense for number on left of >= in ternary condition - registers an offense for number on left in modifier if - registers an offense for number on left of comparison in if condition - registers an offense for nil on left in ternary condition - registers an offense for number on left of <= in ternary condition - with EnforcedStyle: forbid_for_equality_operators_only - accepts nil on left of comparison - accepts number on left of comparison - registers an offense for equality check - accepts mixed order in comparisons - registers an offense for negated equality check - enforce yoda - registers an offense for number on right of comparison - accepts numbers on both sides - accepts arrays of numbers on both sides - accepts accessor and variable on right in boolean expression - accepts string literal on left - accepts instance variable on right - accepts number on left of <=> - accepts negation - accepts string literal on right of case equality check - registers an offense for nil on right - accepts method call on receiver on right - registers an offense for boolean literal on right - accepts subtraction on right of comparison - accepts variable on right after assignment - accepts class variable on right - accepts global variable on right - registers an offense for number on right - registers an offense for string literal on right - accepts assignment - accepts safe navigation on right - with EnforcedStyle: require_for_equality_operators_only - accepts nil on right of comparison - accepts mixed order in comparisons - accepts number on right of comparison - registers an offense for equality check - registers an offense for negated equality check - within an if or ternary statement - registers an offense for number on right of >= in ternary condition - registers an offense for nil on right in ternary condition - registers an offense number on right of comparison in if condition - registers an offense for number on right of <= in ternary condition - registers an offense for number on right in modifier if - registers an offense number on right in if condition +RuboCop::Cop::Style::ExplicitBlockArgument + registers an offense and corrects when multiple arguments are yielded + does not register an offense when `yield` arguments is not a prefix of block arguments + does not register an offense when `yield` is the sole block body + registers an offense and corrects when method contains multiple `yield`s + does not register an offense when arguments are yielded in a different order + registers an offense and corrects when `yield` inside block has no arguments + registers an offense and corrects when `yield` is inside block of `super` + does not add extra parens to `super` when correcting + adds to the existing arguments when correcting + does not register an offense when `yield` is not inside block + does not add extra parens when correcting + correctly corrects when method already has an explicit block argument + does not register an offense when code is called outside of a method + registers an offense and corrects when block just yields its arguments + correctly corrects when using safe navigation method call + does not register an offense when there is more than one block argument and not all are yielded + correctly corrects when the method call has a trailing comma in its argument list -RuboCop::Cop::Lint::DuplicateMethods - registers an offense for duplicate nested method in self method of dynamic class - understands class << self - registers an offense for duplicate class methods in dynamic module - registers an offense for duplicate protected methods in dynamic class - doesn't register an offense for different private methods in dynamic module - registers an offense for duplicate attr in dynamic class - understands class << self - accepts for attr_reader and setter in class_eval block - registers an offense for duplicate private self methods in dynamic module - registers an offense for duplicate method in dynamic class - accepts for non-duplicate alias_method in class_eval block - doesn't register an offense for alias for gvar in class - understands nested modules - does not register an offense for same method name defined in different methods - registers an offense for duplicate nested method in dynamic module - registers an offense for duplicate protected methods in dynamic module - registers an offense for duplicate private self methods in module - registers an offense for duplicate attr_reader in module - doesn't register an offense for non-duplicate alias in class - registers an offense for duplicate class methods with `<<` and named receiver in class - accepts for attr_writer and getter in dynamic module - registers an offense for duplicate alias_method in module - understands nested modules - handles class_eval with implicit receiver - only registers an offense for the second instance of a duplicate instance method in separate files - doesn't register an offense for alias for gvar in dynamic class - registers an offense for duplicate method in class - registers an offense for duplicate attr_writer in module - registers an offense for a duplicate instance method in separate dynamic class blocks - registers an offense for a duplicate class method in separate module blocks - registers offenses for duplicate attr_accessor in module - registers offenses for duplicate assignable attr in class_eval block - registers an offense for duplicate nested method in self method of class - properly registers and offense when deeply nested - registers an offense for a duplicate instance method in separate module blocks - registers 2 offenses for pair of duplicate methods in module - understands class << self - registers an offense for duplicate class methods in dynamic class - registers an offense for duplicate class methods in class_eval block - registers an offense for duplicate class methods in module - does not register an offense for same method name defined in different methods - registers an offense for duplicate alias in class_eval block - registers an offense for duplicate class methods with `self` and named receiver in class - doesn't register offense for non-duplicate class methods in class_eval block - registers an offense when class << exp is used - understands class << self - understands class << A - registers an offense for duplicate methods at top level - recognizes difference between instance and class methods in module - registers an offense for duplicate nested method in class - doesn't register offense for non-duplicate class methods in dynamic module - registers an offense for duplicate nested method in module - doesn't register an offense for non-duplicate alias in dynamic class - registers an offense for a duplicate instance method in separate dynamic module blocks - doesn't register an offense for non-duplicate method in module - registers an offense when class << exp is used - accepts for attr_writer and getter in dynamic class - does not register an offense for same method name defined in different self methods - registers an offense for duplicate alias_method in class - registers offenses for duplicate assignable attr in module - doesn't register offense for non-duplicate class methods in module - registers an offense for duplicate attr_reader in dynamic module - registers 2 offenses for pair of duplicate methods in dynamic module - understands nested modules - registers offenses for duplicate attr_accessor in dynamic class - registers an offense for duplicate attr_reader in class_eval block - registers an offense for a duplicate class method in separate dynamic module blocks - registers 2 offenses for pair of duplicate methods in dynamic class - does not register an offense for same method name defined in different methods - doesn't register an offense for non-duplicate alias in dynamic module - registers an offense for duplicate nested method in self method of dynamic module - doesn't register offense for non-duplicate class methods in class - registers an offense for duplicate attr_reader in dynamic class - ignores method definitions in RSpec `describe` blocks - registers an offense for a duplicate instance method in separate class blocks - registers an offense for duplicate nested method in dynamic class - registers an offense for duplicate alias_method in class_eval block - doesn't register an offense for non-duplicate alias in class_eval block - registers offenses for duplicate assignable attr in dynamic class - registers an offense for duplicate method in dynamic module - registers an offense for duplicate attr in module - accepts for attr_reader and setter in dynamic class - accepts for attr_writer and getter in module - doesn't register an offense for different private methods in class - accepts for non-duplicate alias_method in module - registers an offense for duplicate nested method in class_eval block - accepts for non-duplicate alias_method in dynamic module - registers 2 offenses for pair of duplicate methods in class - registers an offense for duplicate method in class_eval block - registers an offense for duplicate nested method in self method of module - doesn't register an offense for non-duplicate method in dynamic class - understands nested modules - accepts for attr_reader and setter in dynamic module - registers an offense for duplicate private methods in class - registers an offense for duplicate protected methods in class_eval block - registers an offense for duplicate nested method in self method of class_eval block - registers an offense for duplicate class methods with `<<` and named receiver in module - only registers an offense for the second instance of a duplicate instance method in separate files - registers an offense for duplicate alias_method in dynamic class - doesn't register an offense for non-duplicate method in class_eval block - registers an offense for duplicate private self methods in class_eval block - doesn't register an offense for alias for gvar in module - registers an offense for duplicate attr_writer in dynamic module - registers offenses for duplicate attr_accessor in class_eval block - doesn't register an offense for non-duplicate method in class - registers an offense for duplicate attr_writer in dynamic class - does not register an offense for same method name defined in different self methods - registers an offense when class << exp is used - registers 2 offenses for pair of duplicate methods in class_eval block - registers an offense for duplicate attr in dynamic module - recognizes difference between instance and class methods in class - registers offenses for duplicate assignable attr in class - registers an offense for duplicate class methods with named receiver in class - does not register an offense for same method name defined in different methods - doesn't register an offense for non-duplicate method in dynamic module - registers an offense for duplicate alias in module - only registers an offense for the second instance of a duplicate instance method in separate files - registers an offense for duplicate attr_reader in class - does not register an offense for same method name defined in different methods - does not register an offense for same method name defined in different self methods - ignores Class.new blocks which are assigned to local variables - registers an offense for duplicate method in module - registers an offense for duplicate alias_method in dynamic module - registers an offense for duplicate attr in class_eval block - doesn't register offense for non-duplicate class methods in dynamic class - does not register an offense for same method name defined in different self methods - registers an offense for duplicate attr_writer in class_eval block - does not register an offense for same method name defined in different self methods - registers an offense when class << exp is used - only registers an offense for the second instance of a duplicate instance method in separate files - registers an offense for duplicate class methods with `self` and named receiver in module - doesn't register an offense for different private methods in dynamic class - registers an offense for duplicate alias in dynamic class - registers an offense for duplicate private methods in class_eval block - registers an offense for duplicate protected methods in module - registers an offense for a duplicate class method in separate class_eval block blocks - doesn't register an offense for different private methods in module - registers an offense for duplicate alias in dynamic module - registers an offense for duplicate protected methods in class - registers an offense for duplicate private methods in dynamic module - registers an offense for duplicate private methods in module - registers an offense for duplicate private methods in dynamic class - accepts for attr_writer and getter in class - registers an offense when class << exp is used - understands nested modules - registers an offense for a duplicate instance method in separate class_eval block blocks - recognizes difference between instance and class methods in dynamic class - only registers an offense for the second instance of a duplicate instance method in separate files - accepts for attr_reader and setter in class - registers offenses for duplicate attr_accessor in class - recognizes difference between instance and class methods in class_eval block - registers an offense for a duplicate class method in separate class blocks - registers an offense for duplicate alias in class - registers an offense for duplicate private self methods in class - registers an offense for duplicate attr in class - recognizes difference between instance and class methods in dynamic module - understands class << self - doesn't register an offense for alias for gvar in dynamic module - registers an offense for duplicate class methods with named receiver in module - registers offenses for duplicate attr_accessor in dynamic module - registers an offense for a duplicate class method in separate dynamic class blocks - registers an offense for duplicate attr_writer in class - does not register for the same method in different scopes within `class << self` - doesn't register an offense for alias for gvar in class_eval block - registers an offense for duplicate class methods in class - registers an offense for duplicate private self methods in dynamic class - registers offenses for duplicate assignable attr in dynamic module - accepts for non-duplicate alias_method in dynamic class - accepts for non-duplicate alias_method in class - doesn't register an offense for non-duplicate alias in module - accepts for attr_writer and getter in class_eval block - doesn't register an offense for different private methods in class_eval block - accepts for attr_reader and setter in module - when path is not in the project root - adds a message with absolute path - when path is in the project root - adds a message with relative path +RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces + registers an offense for correct + opposite + can handle interpolation in a braceless hash literal + accepts hashes with spaces by default + registers an offense for hashes with no spaces if so configured + accepts hash literals with no braces + when EnforcedStyle is no_space + registers an offense for hashes with spaces + registers an offense for opposite + correct + accepts multiline hash with comment + accepts hashes with no spaces + accepts multiline hash + when using method argument that both key and value are hash literals + accepts hashes with no spaces + with space inside empty braces not allowed + accepts empty braces with no space inside + registers an offense for empty braces with space inside + with space inside empty braces allowed + accepts empty braces with space inside + registers an offense for empty braces with no space inside + when using method argument that both key and value are hash literals + registers hashes with no spaces + on { key: "{" } + does not register an offense + with newline inside empty braces not allowed + registers an offense + offending hash following empty hash + registers an offense on both sides + when EnforcedStyle is compact + registers an offense for opposite + correct + registers offenses for hashes with no spaces + registers an offense for nested hashes with spaces + accepts multiline hash with comment + doesn't register an offense for non-nested hashes with spaces + accepts multiline hash + on Hash[{ x: 1 } => [1]] + does not register an offense -RuboCop::Cop::Style::SingleArgumentDig - dig over a variable as caller - with multiple arguments - does not register an offense - when using multiple `dig` in a method chain - registers and corrects an offense - with single argument - registers an offense and corrects unsuitable use of dig - when using dig with splat operator - does not register an offense - >= Ruby 2.7 - when using dig with arguments forwarding - does not register an offense - when without a receiver +RuboCop::Cop::Lint::NonDeterministicRequireOrder + when not requiring files does not register an offense - dig over literal - when using dig with splat operator + when requiring files + with sorted glob does not register an offense - with single argument - registers an offense and corrects unsuitable use of dig - with multiple arguments + with sorted index does not register an offense - -RuboCop::Cop::VariableForce::Variable - .new - when non variable declaration node is passed - raises error - #referenced? - when the variable has an assignment - and the variable is not yet referenced - is expected to be falsey - and the variable is referenced - is expected to be truthy - when the variable is not assigned - is expected to be falsey - and the variable is referenced - is expected to be truthy - -RuboCop::Cop::Lint::RequireParentheses - accepts method calls without parentheses followed by keyword and/or - registers an offense for missing parentheses around expression with && operator - accepts missing parentheses around expression with + operator - registers an offense for missing parentheses around expression in ternary - accepts missing parentheses when method is not a predicate - accepts missing parentheses when using ternary operator in square bracksts - accepts calls to methods that are setters - accepts calls to methods that are operators - accepts parentheses around expression with boolean operator - accepts condition that is not a call - accepts missing parentheses when using ternary operator - accepts method call with parentheses in ternary - registers an offense for missing parentheses around expression with || operator - accepts method calls that are all operations - when using safe navigation operator - registers an offense for missing parentheses around expression with && operator - -RuboCop::Cop::Lint::UriRegexp - does not register an offense when using `regexp` without receiver - does not register an offense when using `regexp` with variable receiver - registers an offense and corrects using `URI.regexp` with argument - registers an offense and corrects using `::URI.regexp` with argument - registers an offense and corrects using `URI.regexp` without argument - registers an offense and corrects using `::URI.regexp` without argument - array argument - registers an offense and corrects using `URI.regexp` with %w arrays - registers an offense and corrects using `URI.regexp` with %i arrays - registers an offense and corrects using `URI.regexp` with literal arrays - -RuboCop::ResultCache - .cleanup - removes the oldest files in the cache if needed - the cache path - when CacheRootDirectory is set - contains the given root - and RUBOCOP_CACHE_ROOT is set - contains the root from RUBOCOP_CACHE_ROOT - when CacheRootDirectory not set - and XDG_CACHE_HOME is not set - contains $HOME/.cache - and XDG_CACHE_HOME is set - contains the given path and UID - #save - when the @path is not writable - behaves like invalid cache location - doesn't raise an exception - behaves like invalid cache location - doesn't raise an exception - when the default internal encoding is UTF-8 - writes non UTF-8 encodable data to file with no exception - cached result that was saved with no command line option - when no option is given - is valid and can be loaded - when team external_dependency_checksum changes - is invalid - when file contents have changed - is invalid - when a symlink is present in the cache location - and symlink attack protection is disabled - permits caching and prints no warning - and symlink attack protection is enabled - prevents caching and prints a warning - when team external_dependency_checksum is the same - is valid - when file permission have changed - is invalid - when end of line characters have changed - is invalid - when --format is given - is valid and can be loaded - when --only is given - is invalid - when --cache-root is given - takes the cache_root from the options - when a cache source is read - has utf8 encoding - when --display-cop-names is given - is invalid - when offenses are saved - an offense with status corrected - serializes them with uncorrected status - an offense with status corrected_with_todo - serializes them with uncorrected status - an offense with status new_status - serializes them with new_status status - an offense with status uncorrected - serializes them with uncorrected status - an offense with status unsupported - serializes them with unsupported status - -RuboCop::Cop::Layout::CommentIndentation - when allow_for_alignment is true - registers offenses and corrects before __END__ but not after - registers an offense and corrects - accepts comments with extra indentation if aligned with comment on previous line - on outer level - registers an offense and corrects a documentation comment - accepts a correctly indented comment - registers an offense and corrects an incorrectly indented (1) comment - registers an offense and corrects an incorrectly indented (2) comment - accepts a comment that follows code - registers an offense for each incorrectly indented comment - near various kinds of brackets - is unaffected by closing bracket that does not begin a line - accepts correctly indented comments - around program structure keywords - accepts correctly indented comments - with a blank line following the comment - accepts a correctly indented comment - when allow_for_alignment is false - registers offenses and corrects before __END__ but not after - registers an offense for comments with extra indentation - registers an offense and corrects - on outer level - registers an offense and corrects an incorrectly indented (1) comment - accepts a comment that follows code - registers an offense and corrects a documentation comment - registers an offense and corrects an incorrectly indented (2) comment - accepts a correctly indented comment - registers an offense for each incorrectly indented comment - around program structure keywords - accepts correctly indented comments - with a blank line following the comment - accepts a correctly indented comment - near various kinds of brackets - accepts correctly indented comments - is unaffected by closing bracket that does not begin a line - -RuboCop::Cop::Lint::NestedPercentLiteral - registers offense for repeated nested percent literals - registers no offense for percent modifier character in isolation - registers no offense for array - registers offense for multiply nested percent literals - registers offense for nested percent literals - registers no offense for nestings under percent - registers no offense for percents in the middle of literals - registers no offense for empty array - when handling invalid UTF8 byte sequence - registers no offense for array - registers offense for nested percent literal - -RuboCop::Cop::Style::GlobalStdStream - does not register an offense when assigning std stream const to std stream gvar - does not register an offense when assigning other const to std stream gvar - registers an offense and corrects when using std stream as const - does not register an offense when using non std stream const - -RuboCop::Cop::Style::CombinableLoops - when for loop - registers an offense when looping over the same data as previous loop - does not register an offense when each branch contains the same single loop over the same collection - does not register an offense when the same loops are interleaved with some code - does not register an offense when the same loop method is used over different collections - when looping method - does not register an offense when the same loops are interleaved with some code - does not register an offense when the same loop method is used over different collections - does not register an offense for when the same method with different arguments and safe navigation - does not register an offense when different loop methods are used over the same collection - registers an offense when looping over the same data as previous loop - does not register an offense for when the same method with different arguments - does not register an offense when each branch contains the same single loop over the same collection - Ruby 2.7 - registers an offense when looping over the same data as previous loop in numblocks - -RuboCop::Cop::InternalAffairs::NodeTypePredicate - does not register an offense for a predicate node type check - comparison node type check - registers an offense and autocorrects - -RuboCop::Cop::Layout::CaseIndentation - when `when` is on the same line as `case` - registers an offense but does not autocorrect - with EnforcedStyle: end - with IndentOneStep: false - `case` ... `when` - regarding assignment where the right hand side is a `case` - registers an offense and corrects an assignment indented some other way - accepts a correctly indented assignment - `else` and `end` same line - does not register an offense - `when` and `end` same line - does not register an offense - with everything on a single line - does not register an offense - `case` ... `in` - with everything on a single line + when Ruby 3.0 or higher + with direct block glob + does not register an offense + with top-level ::Dir does not register an offense - `in` and `end` same line + with require block passed as parameter does not register an offense - regarding assignment where the right hand side is a `case` - accepts a correctly indented assignment - registers an offense and corrects an assignment indented some other way - with IndentOneStep: true - `case` ... `in` - with everything on a single line + with `Dir.glob` + does not register an offense + with require block passed as parameter does not register an offense - regarding assignment where the right hand side is a `case` - registers an offense and corrects an assignment indented some other way - registers an offense and corrects an assignment indented as `case` - accepts a correctly indented assignment - `case` ... `when` - regarding assignment where the right hand side is a `case` - accepts a correctly indented assignment - registers an offense and corrects an assignment indented some other way - registers an offense and corrects an assignment indented as `case` - with everything on a single line + with top-level ::Dir does not register an offense - with EnforcedStyle: case - with IndentOneStep: true - `case` ... `in` - registers an offense and corrects an `in` clause that is equally indented with `case` - accepts an `in` clause that's 2 spaces deeper than `case` - when indentation width is overridden for this cop only - respects cop-specific IndentationWidth - with everything on a single line + with `sort: false` keyword option does not register an offense - regarding assignment where the right hand side is a `case` - accepts a correctly indented assignment - registers an offense and corrects an assignment indented some other way - `case` ... `when` - accepts a `when` clause that's 2 spaces deeper than `case` - registers an offense and corrects a `when` clause that is equally indented with `case` - regarding assignment where the right hand side is a `case` - registers an offense and corrects an assignment indented some other way - accepts a correctly indented assignment - with everything on a single line + with `Dir[]` + does not register an offense + with top-level ::Dir does not register an offense - when indentation width is overridden for this cop only - respects cop-specific IndentationWidth - with IndentOneStep: false - `case` ... `in` - accepts correctly indented whens in complex combinations - doesn't get confused by symbols named `case` or `in` - registers an offense and corrects an `in` clause that is indented deeper than `case` - doesn't get confused by strings with `case` in them - accepts an `in` clause that's equally indented with `case` - with everything on a single line + with require block passed as parameter does not register an offense - regarding assignment where the right hand side is a `case` - registers an offense and corrects assignment indented some other way - accepts a correctly indented assignment - registers an offense and corrects correct + opposite style - registers an offense and corrects assignment indented as `end` - `case` ... `when` - registers an offense and corrects a `when` clause that is indented deeper than `case` - accepts correctly indented whens in complex combinations - accepts a `when` clause that's equally indented with `case` - doesn't get confused by strings with `case` in them - doesn't get confused by symbols named `case` or `when` - with everything on a single line + with extra logic does not register an offense - regarding assignment where the right hand side is a `case` - registers an offense and corrects correct + opposite style - registers an offense and corrects assignment indented some other way - accepts a correctly indented assignment - registers an offense and corrects assignment indented as end - -RuboCop::Cop::Style::UnpackFirst - ruby version >= 2.4 - does not register offense - when using `#unpack` accessing second element - when using `#unpack1` - registers offense - when using `#unpack` with `#at` - when using `#unpack` with dot and square brackets - when using `#unpack` with `#first` - when using `#unpack` with square brackets - when using `#unpack` with `#slice` + when Ruby 2.7 or lower + with direct block glob + registers an offense and autocorrects to add .sort.each + with top-level ::Dir + registers an offense and corrects to add .sort.each + with require block passed as parameter + registers an offense and autocorrects to add sort + with require_relative block passed as parameter + registers an offense and autocorrects to add sort + with unsorted glob + registers an offense and autocorrects to add .sort + with require block passed as parameter + registers an offense an autocorrects to add sort + with top-level ::Dir + registers an offense and corrects to add .sort + with unsorted index + registers an offense and autocorrects to add .sort when the numblock has `require` + registers an offense with extra logic + registers an offense and autocorrects to add .sort when the block has `require` + registers an offense and autocorrects to add .sort when the block has `require_relative` + with require block passed as parameter + registers an offense an autocorrects to add sort + with top-level ::Dir + registers an offense and corrects to add .sort + with require_relative block passed as parameter + registers an offense an autocorrects to add sort -RuboCop::Cop::Style::ExponentialNotation - EnforcedStyle is scientific - registers no offense for a float smaller than 1 - registers an offense for mantissa equal to 10 - registers no offense for a negative exponent - registers an offense for mantissa smaller than 1 - registers no offense for a mantissa between 1 and 10 - registers no offense for a mantissa equal to 1 - registers an offense for mantissa greater than 10 - registers no offense for a regular float - registers no offense for a negative mantissa - EnforcedStyle is integral - registers an offense for mantissa divisible by 10 - registers an offense for decimal mantissa - registers no offense for a regular float - registers no offense for an integral mantissa - registers no offense for negative exponent - registers no offense for a float smaller than 1 - registers no offense for negative mantissa - EnforcedStyle is engineering - registers an offense for mantissa smaller than -1000 - registers no offense for a float smaller than 1 - registers no offense for a regular float - registers an offense for mantissa smaller than 0.1 - registers an offense for exponent equal to -2 - registers no offense for a mantissa equal to 1 - registers an offense for a mantissa greater than -0.1 - registers no offense for a negative exponent - registers an offense for exponent equal to 4 - registers no offense for a large mantissa - registers no offense for a negative mantissa +RuboCop::Cop::Layout::FirstMethodArgumentLineBreak + ignores arguments listed on a single line + ignores kwargs listed on a single line when the arguments are used in `super` + registers an offense and corrects hash arg spanning multiple lines + ignores methods without arguments + registers an offense and corrects hash arg without a line break before the first pair + ignores arguments without parens + args listed on the first line + registers an offense and corrects using `super` + registers an offense and corrects + registers an offense and corrects using safe navigation operator -RuboCop::Cop::Style::NilLambda - proc - registers an offense when returning nil with `break` - does not register an offense when doing more than returning nil - does not register an offense when not returning nil - registers an offense when returning nil implicitly - registers an offense when returning nil with `return` - does not remove block params or change spacing - registers an offense when returning nil with `next` - properly corrects single line - Proc.new - registers an offense when returning nil with `next` - does not register an offense when not returning nil - does not remove block params or change spacing - does not register an offense when doing more than returning nil - properly corrects single line - registers an offense when returning nil with `break` - registers an offense when returning nil implicitly - registers an offense when returning nil with `return` - block lambda - registers an offense when returning nil with `return` - properly corrects single line - registers an offense when returning nil implicitly - registers an offense when returning nil with `break` - registers an offense when returning nil with `next` - does not remove block params or change spacing - does not register an offense when doing more than returning nil - does not register an offense when not returning nil - stabby lambda - does not register an offense when not returning nil - properly corrects multiline - registers an offense when returning nil implicitly - registers an offense when returning nil with `return` - does not register an offense when doing more than returning nil - registers an offense when returning nil with `break` - registers an offense when returning nil with `next` +RuboCop::Cop::Lint::UnmodifiedReduceAccumulator + behaves like reduce/inject + does not affect inject called with no block args + does not affect inject called without a block + given a inject block + does not register an offense when op-assigning the accumulator + registers an offense when mutating the accumulator with the element but not returning it + registers an offense for values returned with `break` + does not register an offense when returning the accumulator in a boolean statement + registers an offense when called with no argument + does not register an offense when shovelling the accumulator + does not register an offense when returning the accumulator in an expression + does not register an offense when returning a method called with the accumulator + does not register an offense when comparing + registers an offense when returning an expression with the element + does not register an offense when or-assigning the accumulator + registers an offense when returning an index of the accumulator + registers an offense with the element in interpolation + does not register an offense when calling a method on the accumulator with the element + does not register an offense with the accumulator in interpolation + registers an offense when returning accumulator[element]= + registers an offense for values returned with `next` + does not look inside inner blocks + registers an offense when returning an index setter on the accumulator + allows break with no value + registers an offense for every violating return value + does not register an offense with the accumulator in heredoc + does not register an offense when and-assigning the accumulator + does not register an offense when returning a method called on the accumulator + does not register an offense when assigning the accumulator + does not register an offense when mutating the element with the accumulator + does not register an offense when returning a literal + does not register an offense if the return value cannot be determined + registers an offense with the element in heredoc + does not register an offense when returning accumulator[element] + allows the element to be the return value if the accumulator is returned in any branch + does not register an offense when mutating the element with the another value + registers an offense when returning the element + does not register an offense when returning the accumulator + numblocks + does not register an offense when when returning the accumulator + registers an offense when returning the element + argument count + registers an offense when there are more than two arguments but the element is returned + ignores when there are not enough block arguments + ignores when there is a splat argument + behaves like reduce/inject + does not affect reduce called with no block args + does not affect reduce called without a block + given a reduce block + does not register an offense when returning the accumulator + registers an offense when returning an index of the accumulator + does not register an offense when returning a method called with the accumulator + does not register an offense when calling a method on the accumulator with the element + does not register an offense if the return value cannot be determined + does not register an offense when mutating the element with the another value + registers an offense when returning accumulator[element]= + does not register an offense with the accumulator in heredoc + does not register an offense when comparing + does not register an offense when and-assigning the accumulator + registers an offense when returning the element + registers an offense for values returned with `next` + does not register an offense with the accumulator in interpolation + does not register an offense when returning the accumulator in a boolean statement + registers an offense with the element in heredoc + does not register an offense when returning a literal + registers an offense when returning an expression with the element + does not register an offense when or-assigning the accumulator + registers an offense when returning an index setter on the accumulator + allows break with no value + does not register an offense when mutating the element with the accumulator + does not register an offense when returning the accumulator in an expression + allows the element to be the return value if the accumulator is returned in any branch + registers an offense for every violating return value + does not register an offense when shovelling the accumulator + registers an offense for values returned with `break` + does not register an offense when assigning the accumulator + registers an offense when mutating the accumulator with the element but not returning it + does not register an offense when returning accumulator[element] + does not look inside inner blocks + registers an offense with the element in interpolation + registers an offense when called with no argument + does not register an offense when returning a method called on the accumulator + does not register an offense when op-assigning the accumulator + numblocks + registers an offense when returning the element + does not register an offense when when returning the accumulator + argument count + ignores when there are not enough block arguments + ignores when there is a splat argument + registers an offense when there are more than two arguments but the element is returned -RuboCop::Cop::Lint::PercentStringArray - detecting quotes or commas in a %w/%W string - adds an offense and corrects when tokens contain quotes and are comma separated - accepts likely false positive %w(#{a} b) - accepts likely false positive %w(' ") - accepts likely false positive :"#{a}" - adds an offense and corrects when there are no quotes but one comma - adds an offense and corrects when tokens contain both types of quotes - accepts likely false positive %W(' ") - accepts likely false positive %w(' " ! = # ,) - adds an offense and corrects when tokens contain quotes and are comma separated - adds an offense and corrects when there are no quotes but one comma - accepts likely false positive %W(' " ! = # ,) - accepts likely false positive %W(#{a} b) - accepts likely false positive :"#{a}" - adds an offense and corrects when tokens contain both types of quotes - adds an offense and corrects when one token is quoted but there are no commas - adds an offense and corrects when one token is quoted but there are no commas - accepts tokens without quotes or commas - accepts tokens without quotes or commas - with binary encoded source - accepts if tokens contain no quotes - adds an offense and corrects when tokens contain quotes - with invalid byte sequence in UTF-8 - accepts if tokens contain invalid byte sequence only - add an offense and corrects when tokens contain quotes +RuboCop::Cop::Lint::ParenthesesAsGroupedExpression + does not register an offesne when heredoc has a space between the same string as the method name and `(` + does not register an offense for expression followed by an operator + does not register an offense for expression followed by chained expression + accepts an operator call with argument in parentheses + accepts method with parens as arg to method without + does not register an offense for math expression + does not register an offense for math expression with `to_i` + registers an offense and corrects for method call with space before the parenthesis + does not register an offense for a call with multiple arguments + accepts a chain of method calls + does not register an offense for expression followed by chained expression with safe navigation operator + does not register an offense when method argument parentheses are omitted and hash argument key is enclosed in parentheses + does not register an offense for ternary operator + accepts a method call with arguments but no parentheses + accepts a space inside opening paren followed by left paren + accepts a method call without arguments + registers an offense and corrects for predicate method call with space before the parenthesis + when using safe navigation operator + registers an offense and corrects for method call with space before the parenthesis -RuboCop::Cop::InternalAffairs::UselessMessageAssertion - registers an offense for described_class::MSG in let - registers an offense for specs that expect offense using the MSG - registers an offense for specs that assert using the MSG - does not register an offense for an assertion about the message +RuboCop::Cop::InternalAffairs::NodeMatcherDirective + does not insert a blank line if one already exists + retains indentation properly when inserting + inserts a blank line between multiple pattern matchers + autocorrects with the right arguments if the pattern references a non-contiguous argument + does not insert a blank line if one already exists + inserts a blank line between multiple pattern matchers + does not register an offense if called with a dynamic method name + does not register an offense if the node matcher already has a directive + does not register an offense if the directive is in a comment block + registers an offense if the matcher has multiple directives + autocorrects with the right arguments if the pattern includes arguments + retains indentation properly when correcting + registers an offense if the matcher does not have a directive but has preceding comments + registers an offense if the matcher has multiple directives + registers an offense if the matcher does not have a directive + registers an offense if the matcher does not have a directive + registers an offense if the matcher does not have a directive and a method call is used for a pattern argument + inserts a blank line between multiple multi-line pattern matchers + registers an offense if the matcher does not have a directive but has preceding comments + does not register an offense if the directive is in a comment block + inserts a blank line between multiple multi-line pattern matchers + retains indentation properly when correcting + does not register an offense if the node matcher already has a directive + autocorrects with the right arguments if the pattern references a non-contiguous argument + registers an offense if the directive name does not match the actual name + autocorrects with the right arguments if the pattern includes arguments + registers an offense if the matcher does not have a directive and a method call is used for a pattern argument + does not register an offense if called with a dynamic method name + retains indentation properly when inserting + registers an offense if the directive name does not match the actual name + +RuboCop::Cop::Style::BlockComments + autocorrects an empty block comment by removing it + accepts regular comments + registers an offense for block comments + autocorrects a block comment into a regular comment + autocorrects a block comment into a regular comment (without trailingnewline) + +RuboCop::Cop::Generator::RequireFileInjector + when a `require` entry already exists + does not write to any file + when a cop of style department already exists + injects a `require_relative` statement on the end of style department + when using an unknown department + inserts a `require_relative` statement to the bottom of the file + when a `require_relative` entry does not exist from before + injects a `require_relative` statement on the right line in the root file + +RuboCop::Cop::Style::RedundantSort + registers an offense when first is called on sort_by with line breaks and `||` operator + does not register an offense when sort has an argument + registers an offense when last is called with sort + registers an offense when first is called on sort_by + registers an offense when last is called on sort_by + does not register an offense when first is used without sort_by + does not register an offense for sort!.first + registers an offense when [-1] is called on sort_by + registers an offense when first is called on sort_by with line breaks + does not register an offense when first is used before sort + does not register an offense when sort_by is not given a block + does not register an offense when first has an argument + registers an offense when last is called on sort with comparator + registers an offense when at(-1) is called with sort + registers an offense when slice(0) is called on sort + registers an offense when last is called on sort_by no block + registers an offense with `sort_by { a || b }` + does not register an offense when sort_by is used without first + does not register an offense for sort_by!(&:something).last + registers an offense when slice(0) is called on sort_by + registers an offense when [](-1) is called on sort_by + registers an offense when at(0) is called on sort_by + registers an offense when [](0) is called on sort + registers an offense when slice(-1) is called on sort_by + registers an offense when [-1] is called on sort + registers an offense when first is called on sort_by no block + registers an offense when first is called with sort + registers an offense when [0] is called on sort_by + registers an offense when first is called on sort_by with line breaks and `and` operator + registers an offense when first is called on sort_by with line breaks and `&&` operator + registers an offense when [0] is called on sort + registers an offense when first is called on sort_by with line breaks and `or` operator + >= Ruby 2.7 + when using numbered parameter + registers an offense and corrects when at(0) is called on sort_by + registers an offense and corrects when first is called on sort_by + registers an offense and corrects when last is called on sort with comparator + when not taking first or last element + does not register an offense when [1] is called on sort + does not register an offense when at(-2) is called on sort_by + does not register an offense when [-1] is called on sort with an argument + +RuboCop::Cop::Offense + overrides #to_s + does not blow up if a message contains % + redefines == to compare offenses based on their contents + has a few required attributes + is frozen + offenses that span part of a line + highlights the first line + when the location is pseudo + returns a real column + returns the last line + returns a column range + returns the first line + returns a column length + returns a location with valid size and length + returns the last column + returns a column + returns a line + returns a source line + #message + is frozen + #cop_name + is frozen + #<=> + when receiver has {:line=>6} and other has {:line=>5} + returns 1 + when receiver has {:line=>5, :col=>6} and other has {:line=>5, :col=>5} + returns 1 + when receiver has {} and other has {} + returns 0 + when receiver has {:cop=>"B"} and other has {:cop=>"A"} + returns 1 + when receiver has {:line=>6, :col=>4} and other has {:line=>5, :col=>5} + returns 1 + when receiver has {:col=>6, :cop=>"A"} and other has {:col=>5, :cop=>"B"} + returns 1 + when receiver has {:line=>6, :cop=>"A"} and other has {:line=>5, :cop=>"B"} + returns 1 + when unknown severity is passed + raises error + offenses that span multiple lines + highlights the first line + #severity_level + when severity is :info + is 1 + when severity is :refactor + is 2 + when severity is :fatal + is 6 + #location + is frozen + #severity + is frozen + +RuboCop::Cop::Style::RedundantSelf + does not report an offense when lvasgn name is used in `until` + accepts a self receiver used to distinguish from constant + does not report an offense when lvasgn name is used in `if` + accepts a self receiver with the square bracket operator + does not report an offense when masgn name is used in `if` + does not report an offense when receiver and lvalue have the same name + does not report an offense when receiver and multiple assigned lvalue have the same name + accepts when nested receiver and lvalue have the name name + does not report an offense when lvasgn name is used in `while` + accepts a self receiver on an lvalue of mlhs arguments + accepts a self receiver with the double less-than operator + does not report an offense when masgn name is used in `until` + accepts a self receiver on an lvalue of an assignment + does not report an offense when self receiver in a method argument and lvalue have the same name + accepts a self receiver of methods also defined on `Kernel` + accepts a self receiver on an lvalue of a plus-assignment + reports an offense when a different masgn name is used in `if` + accepts a self receiver used to distinguish from argument of block + reports an offense a self receiver of .call + accepts a self receiver on an lvalue of an or-assignment + accepts a self receiver on an lvalue of a parallel assignment + does not report an offense when lvasgn name is nested below `if` + does not report an offense when masgn name is used in `while` + accepts a self receiver on an lvalue of an and-assignment + accepts a self receiver for methods named like ruby keywords + does not report an offense when masgn name is used in `unless` + does not report an offense when self receiver in a method argument and multiple assigned lvalue have the same name + accepts a self receiver of .() + does not report an offense when lvasgn name is used in `unless` + reports an offense a self receiver on an rvalue + reports an offense when a different lvasgn name is used in `if` + instance methods + accepts a self receiver used to distinguish from optional argument + accepts a self receiver used to distinguish from an argument when an inner method is defined + accepts a self receiver used to distinguish from blockarg + accepts a self receiver used to distinguish from an argument + accepts a self receiver used to distinguish from argument + accepts a self receiver used to distinguish from local variable + with ruby >= 2.7 + with pattern matching + registers an offense when using a self receiver with a pin + accepts a self receiver on a `array-pattern` + accepts a self receiver on an `match-var` + registers an offense when using self with a different match var + accepts a self receiver in a conditional pattern + accepts a self receiver in a nested pattern` + accepts a self receiver on a `hash-pattern` + accepts a self receiver with a `match-alt` + accepts a self receiver in a `if-guard` + class methods + accepts a self receiver used to distinguish from local variable + accepts a self receiver used to distinguish from blockarg + accepts a self receiver used to distinguish from argument + accepts a self receiver used to distinguish from optional argument + Ruby 2.7 + registers offense for self usage in numblocks + +RuboCop::ConfigObsoletion::RenamedCop + #message + when the cop has changed names but in a new department + is expected to start with "The `Style/MyCop` cop has been renamed to `Layout/NewCop`" + when the cop has been moved to a new department + is expected to start with "The `Style/MyCop` cop has been moved to `Layout/MyCop`" + when the cop has changed names but in the same department + is expected to start with "The `Style/MyCop` cop has been renamed to `Style/NewCop`" RuboCop::Cop::Style::HashTransformKeys - below Ruby 2.5 - does not flag even if transform_keys could be used when using Ruby 2.5 or newer + does not flag _.map{...}.to_h when both key & value are transformed + does not flag each_with_object when its receiver is array literal + does not flag `each_with_object` when its receiver is `zip` + correctly autocorrects Hash[_.map{...}] + flags _.map{...}.to_h when transform_keys could be used + does not flag each_with_object when both key & value are transformed does not flag `Hash[_.map{...}]` when its receiver is `each_with_index` - does not flag each_with_object when key transformation uses value + does not flag key transformation in the absence of to_h does not flag `_.map{...}.to_h` when its receiver is `zip` + correctly autocorrects _.map{...}.to_h without block + does not flag `Hash[_.map{...}]` when its receiver is `with_index` does not flag `_.map{...}.to_h` when its receiver is `each_with_index` - does not flag `each_with_object` when its argument is used in the key + correctly autocorrects _.map{...}.to_h with block flags Hash[_.map{...}] when transform_keys could be used - correctly autocorrects Hash[_.map{...}] - flags _.map{...}.to_h when transform_keys could be used - does not flag key transformation in the absence of to_h does not flag `Hash[_.map{...}]` when its receiver is an array literal - does not flag `each_with_object` when its receiver is `with_index` - correctly autocorrects _.map{...}.to_h with block - does not flag _.map{...}.to_h when both key & value are transformed - does not flag `_.map{...}.to_h` when its receiver is `with_index` - does not flag `each_with_object` when its receiver is `each_with_index` flags _.map{...}.to_h when transform_keys could be used when line break before `to_h` - does not flag each_with_object when no transformation occurs - does not flag `Hash[_.map{...}]` when its receiver is `with_index` - does not flag _.map {...}.to_h when key block argument is unused - does not flag each_with_object when its argument is not modified - correctly autocorrects _.map{...}.to_h without block - flags _.map {...}.to_h when transform_keys could be used when wrapped in another block - does not flag `each_with_object` when its receiver is `zip` - does not flag each_with_object when both key & value are transformed - does not flag key transformation when receiver is array literal + does not flag `each_with_object` when its receiver is `each_with_index` does not flag `Hash[_.map{...}]` when its receiver is `zip` does not flag Hash[_.map{...}] when both key & value are transformed - does not flag each_with_object when its receiver is array literal + does not flag `_.map{...}.to_h` when its receiver is `with_index` + does not flag key transformation when receiver is array literal + does not flag each_with_object when key transformation uses value + does not flag _.map {...}.to_h when key block argument is unused + does not flag `each_with_object` when its receiver is `with_index` + does not flag `each_with_object` when its argument is used in the key + flags _.map {...}.to_h when transform_keys could be used when wrapped in another block + does not flag each_with_object when its argument is not modified + does not flag each_with_object when no transformation occurs with multiline block flags each_with_object when transform_keys could be used - with inline block - flags each_with_object when transform_keys could be used with safe navigation operator flags each_with_object when transform_keys could be used - below Ruby 2.6 - does not flag _.to_h{...} + with inline block + flags each_with_object when transform_keys could be used when using Ruby 2.6 or newer - does not flag `_.to_h{...}` when its receiver is `zip` does not flag `_.to_h{...}` when its receiver is an array literal - flags _.to_h{...} when transform_keys could be used - does not flag `_.to_h{...}` when its receiver is `with_index` - does not flag `_.to_h{...}` when its receiver is `each_with_index` + does not flag `_.to_h{...}` when its receiver is `zip` does not flag `_.to_h{...}` when both key & value are transformed + flags _.to_h{...} when transform_keys could be used does not flag _.to_h {...} when key block argument is unused + does not flag `_.to_h{...}` when its receiver is `each_with_index` + does not flag `_.to_h{...}` when its receiver is `with_index` + below Ruby 2.5 + does not flag even if transform_keys could be used + below Ruby 2.6 + does not flag _.to_h{...} -RuboCop::Cop::Layout::DefEndAlignment - when EnforcedStyleAlignWith is start_of_line - accepts matching defs ... end - accepts matching def ... end - registers an offense for mismatched def test end and autocorrects - registers an offense for mismatched def Test.test end and autocorrects - registers an offense for mismatched foo def test end and autocorrects - accepts matching def ... end - accepts matching foo bar def ... end - accepts matching foo def ... end - correct + opposite - registers an offense - when including an anonymous module containing `private def` - does not register an offense - when using refinements and `private def` - does not register an offense - when EnforcedStyleAlignWith is def - registers an offense for mismatched def Test.test end and autocorrects - accepts matching def ... end - accepts matching defs ... end - registers an offense for mismatched foo def test end and autocorrects - registers an offense for mismatched def test end and autocorrects - accepts matching foo def ... end - correct + opposite - registers an offense - -RuboCop::Cop::Style::HashEachMethods - when node matches a keys#each or values#each - when receiver is a hash literal - registers offense, autocorrects {}#values.each to {}#each_value with a symbol proc argument - does not register an offense for {}#each_value - registers offense, autocorrects {}#keys.each with {}#each_key - registers offense, autocorrects {}#values.each with {}#each_value - does not register an offense for {}#each_key - registers offense, autocorrects {}#keys.each to {}#each_key with a symbol proc argument - when receiver is implicit - does not register an offense for `keys.each` with a symbol proc argument - does not register an offense for `values.each` - does not register an offense for `keys.each` - does not register an offense for each_value - does not register an offense for `values.each` with a symbol proc argument - does not register an offense for each_key - when receiver is a send - registers offense, autocorrects foo#values.each to foo#each_value with a symbol proc argument - does not register an offense for foo#each_key - registers offense, autocorrects foo#keys.each to foo#each_key - registers offense, autocorrects foo#keys.each to foo#each_key with a symbol proc argument - registers offense, autocorrects foo#values.each to foo#each_value - does not register an offense for Hash#each_value - Ruby 2.7 - registers offense, autocorrects foo#keys.each to foo#each_key with numblock - when `AllowedReceivers: ['execute']` - does not register an offense when receiver is `execute` method - registers an offense when receiver is not allowed name - does not register an offense when receiver is `execute` variable - does not register an offense when receiver is `execute` method with a symbol proc argument - -RuboCop::Ext::RegexpNode - #each_capture - when called with a `named: true` - is expected to match [(be an instance of Regexp::Expression::Group::Named)] - when called with a `named: false` - is expected to match [(be an instance of Regexp::Expression::Group::Capture)] - when called without argument - is expected to match [(be an instance of Regexp::Expression::Group::Capture), (be an instance of Regexp::Expression::Group::Named)] - #parsed_tree - with a regexp with subexpressions - has location information - with a regexp not containing interpolation - returns the expected tree - with an extended mode regexp with comment - returns the expected tree - with a regexp containing interpolation - returns the expected blanked tree - with a regexp containing a multi-line interpolation - returns the expected blanked tree - -RuboCop::Cop::Style::StabbyLambdaParentheses - require_parentheses - registers an offense for a stabby lambda without parentheses - does not register an offense for a stabby lambda with parentheses - behaves like common - does not check a method call named lambda - does not check a stabby lambda without arguments - does not check the old lambda syntax - require_no_parentheses - registers an offense for a stabby lambda with parentheses - behaves like common - does not check a method call named lambda - does not check a stabby lambda without arguments - does not check the old lambda syntax - -RuboCop::Cop::Style::RedundantParentheses - registers an offense and corrects for a parenthesized item in a hash where the comma is on a line with the closing parens - accepts parentheses around an irange - registers an offense for parens around an integer exponentiation base - registers an offense for parens around a literal in array and following newline - registers an offense for parens around a float exponentiation base - accepts parentheses around operator keywords - registers an offense when there is space around the parentheses - accepts parentheses in yield call with hash - registers an offense for parens around a block body - registers an offense for parens around an interpolated expression - registers an offense and corrects an array of multiple heredocs - registers an offense and corrects when method arguments are unnecessarily parenthesized - accepts parentheses around a method call with unparenthesized arguments - accepts parentheses when enclosed in parentheses at `until-post` - accepts parentheses inside an erange - accepts parentheses in super call with hash - registers an offense for parens around a receiver of a method call with an argument - accepts parentheses inside an irange - registers an offense for parens around a literal in array - registers an offense for parens around last expressions in method body - accepts parentheses when they touch the following keyword - accepts parentheses when they touch the preceding keyword - accepts parentheses around a constant passed to when - registers an offense for parens around a variable after semicolon - registers an offense for parens around a literal hash value and following newline - registers an offense for parens around a positive exponent - registers an offense for parens around a literal hash value - registers an offense for parens around method body - registers an offense for parens around last expressions in block body - accepts parentheses when enclosed in parentheses at `while-post` - accepts parentheses around the error passed to rescue - accepts parentheses around an erange - registers an offense for parens around a negative exponent - when a hash literal is the second argument in a method call - registers an offense - behaves like redundant - registers an offense for parentheses around a method call - when parentheses are used like method argument parentheses - accepts parens around the arg - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a constant - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a variable - behaves like redundant - registers an offense for parentheses around a literal - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like keyword with arguments - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around an unary operation - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a literal - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around an unary operation - pin operator - behaves like allowed parentheses - accepts parentheses on a method call on a global variable - behaves like redundant parentheses - registers an offense and corrects a class variable - behaves like allowed parentheses - accepts parentheses on a method call on an instance variable - behaves like allowed parentheses - accepts parentheses on a method call on a class variable - behaves like allowed parentheses - accepts parentheses on an int literal - behaves like redundant parentheses - registers an offense and corrects an instance variable - behaves like allowed parentheses - accepts parentheses on an array literal - behaves like allowed parentheses - accepts parentheses on a function call with no arguments - behaves like allowed parentheses - accepts parentheses on a function call with arguments - behaves like redundant parentheses - registers an offense and corrects a local variable - behaves like allowed parentheses - accepts parentheses on a method call on a local variable - behaves like allowed parentheses - accepts parentheses on a hash literal - behaves like allowed parentheses - accepts parentheses on a range literal - behaves like allowed parentheses - accepts parentheses on an expression - behaves like redundant parentheses - registers an offense and corrects a global variable - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - literals in an array - when there is a comma on the same line as the closing parentheses - registers an offense and corrects when there is a subsequent item - registers an offense and corrects when there is no subsequent item - registers an offense and corrects when there is a trailing comma - registers an offense and corrects when there is assignment - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like keyword with return value - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a variable - behaves like redundant - registers an offense for parentheses around a variable - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a keyword - behaves like keyword with arguments - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - when a non-parenthesized call has an arg and a block - accepts parens around the arg - behaves like redundant - registers an offense for parentheses around an unary operation - behaves like redundant - registers an offense for parentheses around a method call - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like keyword with return value - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a method call - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a literal - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a method call - behaves like redundant - registers an offense for parentheses around a literal - ternaries - when Style/TernaryParentheses has EnforcedStyle: require_no_parentheses - registers an offense for parens around ternary condition - when Style/TernaryParentheses has EnforcedStyle: require_parentheses - behaves like plausible - accepts parentheses when arguments are unparenthesized - when Style/TernaryParentheses is not enabled - registers an offense for parens around constant ternary condition - when Style/TernaryParentheses has EnforcedStyle: require_parentheses_when_complex - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a method call - behaves like redundant - registers an offense for parentheses around an unary operation - behaves like keyword with return value - behaves like redundant - registers an offense for parentheses around a keyword - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a keyword - behaves like redundant - registers an offense for parentheses around a method call - behaves like redundant - registers an offense for parentheses around a method call - behaves like redundant - registers an offense for parentheses around a method call - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like redundant - registers an offense for parentheses around a method call - when the first argument in a method call begins with a hash literal - accepts parentheses if the argument list is not parenthesized - registers an offense if the argument list is parenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - behaves like plausible - accepts parentheses when arguments are unparenthesized - -RuboCop::Cop::Metrics::CyclomaticComplexity - when AllowedMethods is enabled - does not register an offense when using `define_method` - does not register an offense when defining a class method - does not register an offense when defining an instance method - when AllowedPatterns is enabled - does not register an offense when using `define_method` - does not register an offense when defining a class method - does not register an offense when defining an instance method - when Max is 2 - counts stupid nested if and else blocks - when Max is 1 - registers an offense for a case/when block - registers an offense for a for block - accepts an empty `define_method` - registers an offense for an if modifier - registers an offense for an until block - does not count blocks in general - registers an offense for an elsif block - accepts an empty method - registers an offense for &&= - deals with nested if blocks containing && and || - registers an offense for ||= - registers an offense for and - counts enumerating methods with blocks as +1 - counts only a single method - registers an offense for || - counts enumerating methods with block-pass as +1 - registers an offense for an unless modifier - accepts a method with no decision points - registers an offense for &. - registers an offense for a rescue block - registers an offense for && - registers an offense for or - registers an offense for a `define_method` - counts repeated &. on same untouched local variable as 1 - registers an offense for a ternary operator - accepts complex code outside of methods - registers an offense for a while block - Ruby 2.7 - counts enumerating methods with numblocks as +1 - -RuboCop::Cop::Style::RedundantConditional - registers an offense for if/elsif/else with boolean results - registers an offense for if/else with boolean results - does not register an offense for if/else with non-boolean results - does not register an offense for if/elsif/else with non-boolean results - registers an offense for if/elsif/else with negated boolean results - allows ternary with non-boolean results - registers an offense for if/else with negated boolean results - registers an offense for ternary with boolean results - registers an offense for ternary with negated boolean results - -RuboCop::Cop::Style::GlobalVars - does not register an offense for built-in variable $DEFAULT_INPUT - does not register an offense for built-in variable $\ - does not register an offense for built-in variable $. - does not register an offense for built-in variable $ORS - does not register an offense for built-in variable $; - does not register an offense for built-in variable $INPUT_LINE_NUMBER - does not register an offense for built-in variable $_ - does not register an offense for built-in variable $DEBUG - does not register an offense for built-in variable $INPUT_RECORD_SEPARATOR - does not register an offense for built-in variable $-w - does not register an offense for built-in variable $VERBOSE - does not register an offense for built-in variable $PREMATCH - does not register an offense for built-in variable $' - does not register an offense for built-in variable $ERROR_INFO - does not register an offense for built-in variable $FS - does not register an offense for built-in variable $& - does not register an offense for built-in variable $LAST_MATCH_INFO - does not register an offense for built-in variable $ARGV - does not register an offense for built-in variable $POSTMATCH - allows user permitted variables - does not register an offense for built-in variable $LAST_PAREN_MATCH - does not register an offense for built-in variable $MATCH - does not register an offense for built-in variable $/ - does not register an offense for built-in variable $-i - does not register an offense for built-in variable $: - does not register an offense for built-in variable $JRUBY_REVISION - does not register an offense for backrefs like $1 - does not register an offense for built-in variable $@ - does not register an offense for built-in variable $-F - does not register an offense for built-in variable $0 - does not register an offense for built-in variable $FILENAME - does not register an offense for built-in variable $~ - does not register an offense for built-in variable $IGNORECASE - does not register an offense for built-in variable $PID - does not register an offense for built-in variable $* - does not register an offense for built-in variable $` - does not register an offense for built-in variable $! - does not register an offense for built-in variable $OUTPUT_RECORD_SEPARATOR - does not register an offense for built-in variable $PROGRAM_NAME - does not register an offense for built-in variable $CHILD_STATUS - does not register an offense for built-in variable $-d - does not register an offense for built-in variable $-v - does not register an offense for built-in variable $LOAD_PATH - does not register an offense for built-in variable $-I - does not register an offense for built-in variable $-p - does not register an offense for built-in variable $NR - does not register an offense for built-in variable $stderr - does not register an offense for built-in variable $stdin - does not register an offense for built-in variable $CLASSPATH - does not register an offense for built-in variable $OUTPUT_FIELD_SEPARATOR - does not register an offense for built-in variable $RS - does not register an offense for built-in variable $LAST_READ_LINE - does not register an offense for built-in variable $stdout - does not register an offense for built-in variable $LOADED_FEATURES - does not register an offense for built-in variable $SAFE - does not register an offense for built-in variable $-a - does not register an offense for built-in variable $= - does not register an offense for built-in variable $? - does not register an offense for built-in variable $> - does not register an offense for built-in variable $ERROR_POSITION - does not register an offense for built-in variable $-l - does not register an offense for built-in variable $JRUBY_VERSION - does not register an offense for built-in variable $ENV_JAVA - does not register an offense for built-in variable $< - does not register an offense for built-in variable $PROCESS_ID - registers an offense for $custom - does not register an offense for built-in variable $$ - does not register an offense for built-in variable $, - does not register an offense for built-in variable $DEFAULT_OUTPUT - does not register an offense for built-in variable $+ - does not register an offense for built-in variable $-0 - does not register an offense for built-in variable $" - does not register an offense for built-in variable $OFS - does not register an offense for built-in variable $FIELD_SEPARATOR - -RuboCop::Cop::Lint::EmptyFile - does not register an offense when the file contains comments - does not register an offense when the file contains code - registers an offense when the file is empty - when AllowComments is false - registers an offense when the file contains comments - -RuboCop::Cop::Style::OptionHash - registers an offense - when there are no arguments - does not register an offense - when passing options hash to super - does not register an offense when call to super is in a nested block - does not register an offense when code exists before call to super - does not register an offense - when the last argument is a non-options-hash optional hash - does not register an offense - permitted list - ignores if the method is permitted - when the last argument is an options hash named something else - does not register an offense - when the argument name is in the list of suspicious names - registers an offense - -RuboCop::Cop::Style::RedundantBegin - reports an offense when multi-line `begin` block has single statement with modifier condition - reports an offense when assigning nested `begin` blocks - does not register an offense when using `begin` for method argument - accepts when one-liner `begin` block has multiple statements with modifier condition - does not register an offense when using `begin` with `ensure` - registers an offense and corrects when using `begin` without `rescue` or `ensure` - does not register an offense when using `begin` for semantic operator conditions - reports an offense for single line def with redundant begin block - registers and corrects an offense when using multi-line `if` in `begin` block - does not register an offense when using `begin` for logical operator conditions - reports an offense for def with redundant begin block - reports an offense for defs with redundant begin block - registers and corrects an offense when using `begin` with single statement for or assignment - does not register an offense when using `begin` with no statements for or assignment - doesn't modify spacing when autocorrecting - does not register an offense when using `begin` for or assignment and method call - does not register an offense when using body of `begin` is empty - registers and corrects an offense when using modifier `if` single statement in `begin` block - reports an offense when one-liner `begin` block has single statement with modifier condition - autocorrects when there are trailing comments - does not register an offense when using `begin` with `rescue` - does not register an offense when using `begin` with `until` - reports an offense when multi-line `begin` block has single statement and it is inside condition - accepts a defs with required begin block - accepts when multi-line `begin` block has multiple statements with modifier condition - registers and corrects an offense when using `begin` with single statement that called a block for or assignment - accepts a def with a begin block after a statement - does not register an offense when using `begin` with multiple statement for or assignment - reports an offense when assigning nested blocks which contain `begin` blocks - does not register an offense when using `begin` with `while` - does not register an offense when using `begin` for assignment - accepts a def with required begin block - Ruby 2.7 - reports an offense when assigning nested blocks which contain `begin` blocks - when using endless method definition - accepts when `begin` block has multiple statements - registers when `begin` block has a single statement - accepts when `begin` block has no statements - >= ruby 2.5 - accepts a {} block with a begin-end - accepts a block with a begin block after a statement - registers an offense for a do-end block with redundant begin-end - accepts a stabby lambda with a begin-end - accepts super with block - < Ruby 2.5 - accepts a do-end block with a begin-end - -RuboCop::Cop::Lint::InheritException - when class inherits from `Exception` - with enforced style set to `standard_error` - registers an offense and corrects - when inheriting a standard lib exception class that is not a subclass of `StandardError` - does not register an offense - when creating a subclass using Class.new - registers an offense and corrects - with enforced style set to `runtime_error` - registers an offense and corrects - when creating a subclass using Class.new - registers an offense and corrects - when inheriting a standard lib exception class that is not a subclass of `StandardError` - does not register an offense - -RuboCop::Cop::Layout::EmptyComment - register offenses and correct multiple empty comments next to code - does not register an offense when using comment text - registers an offense and corrects using multiline empty comments - registers an offense and corrects an empty comment without space next to code - does not register an offense when using comment text with leading and trailing blank lines - register offenses and correct multiple aligned empty comments next to code - registers an offense and corrects using an empty comment next to code - registers an offense and corrects using single line empty comment - disallow border comment - registers an offense and corrects using border comment - registers an offense and corrects using single line empty comment - disallow margin comment - registers an offense and corrects using margin comment - allow border comment (default) - does not register an offense when using border comment - allow margin comment (default) - does not register an offense when using margin comment - -RuboCop::Cop::Bundler::InsecureProtocolSource - registers an offense when using `source :rubyforge` - does not register an offense when using `source 'https://rubygems.org'` - registers an offense when using `source :rubygems` - registers an offense when using `source :gemcutter` - when `AllowHttpProtocol: false` - registers an offense when using `source 'http://rubygems.org'` - when `AllowHttpProtocol: true` - does not register an offense when using `source 'http://rubygems.org'` - -RuboCop::Cop::Style::EvenOdd - converts (x._(y) % 2) != 1 to even? - converts x % 2 != 1 to #even? - converts x % 2 == 0 to #even? - converts (x._(y)) % 2 != 1 to even? - converts x % 2 == 1 to #odd? - accepts x % 2 == 2 - converts (x % 2) != 0 to #odd? - converts x % 2 != 0 to #odd? - converts (y % 2) != 1 to #even? - converts (x.y % 2) != 1 to #even? - converts (x % 2) == 0 to #even? - converts 1 % 2 != 1 to even? - converts (x(y) % 2) != 1 to #even? - converts (x % 2) == 1 to #odd? - accepts x % 3 == 0 - converts x._(y) % 2 != 1 to even? - converts complex examples - accepts x % 3 != 0 - -RuboCop::Cop::Style::BeginBlock - reports an offense for a BEGIN block - -RuboCop::Cop::Style::Documentation - accepts non-empty class with comment that ends with an annotation - accepts namespace class without documentation - does not consider comment followed by empty line to be class documentation - accepts namespace module which defines constants - accepts non-empty class with documentation - registers an offense for a deeply nested class - registers an offense for non-empty cbase class - registers an offense for compact-style nested module - registers an offense for non-empty class - registers offense for non-empty class with frozen string comment - registers an offense for empty module without documentation - accepts non-empty module with documentation - accepts namespace module without documentation - accepts namespace class which defines constants - accepts non-empty class with annotation comment followed by other comment - registers an offense if the comment line contains code - accepts empty class without documentation - does not raise an error for an implicit match conditional - registers an offense for non-empty class with encoding comment - registers an offense for non-empty class with directive comment - registers an offense for compact-style nested class - registers an offense for non-empty class with annotation comment - registers an offense for non-namespace - sparse and trailing comments - ignores comments after class node end - ignores comments after module node end - ignores sparse comments inside module node - ignores sparse comments inside class node - with # :nodoc: - accepts compact-style nested class without documentation - accepts non-namespace class without documentation - accepts non-namespace module without documentation - registers an offense for nested class without documentation - registers an offense for nested module without documentation - accepts compact-style nested module without documentation - with `all` modifier - accepts nested module without documentation - with `all` modifier - accepts nested class without documentation - on a subclass - registers an offense for nested subclass without documentation - accepts non-namespace subclass without documentation - with `all` modifier - accepts nested subclass without documentation - when AllowedConstants is configured - ignores the constants in the config - without documentation - with non-empty module - with constants visibility declaration content - does not register an offense - with non-empty class - with constants visibility declaration content - does not register an offense - macro-only class - registers offense for macro with other methods - does not register offense with multiple macros - does not register offense with single macro - -RuboCop::Formatter::TextUtil - pluralize - will pluralize negative quantities less than -1 - will pluralize fractions - will pluralize quantities greater than 1 - will change 0 to no when configured - will pluralize -1 - will not pluralize 1 - will not change 0 to no - -RuboCop::Cop::Layout::EmptyLines - registers an offense for consecutive empty lines - does not register an offense for empty lines in a string - does not register an offense for heredocs with empty lines inside - does not register an offense for comments - does not register an offense when there are no tokens - -RuboCop::Cop::InternalAffairs::ExampleDescription - with `expect_no_offenses` - registers an offense when given an improper description - does not register an offense when given a proper description - does not crash when given a proper description that is split with + - does not register an offense when given an unexpected description - with `expect_correction` - registers an offense when given an improper description - in conjunction with expect_offense - registers an offense when given an improper description - when the description is invalid for both methods - registers an offense for the first method encountered - with `expect_offense` - does not register an offense when given an unexpected description - does not register an offense when given a proper description - registers an offense when given an improper description - with `expect_no_corrections` - registers an offense when given an improper description - in conjunction with expect_offense - registers an offense when given an improper description - when not making an expectation on offenses - does not register an offense - -RuboCop::Cop::Naming::HeredocDelimiterNaming - with a naked heredoc - registers an offense with a non-meaningful delimiter - does not register an offense with a meaningful delimiter - with a squiggly heredoc - does not register an offense with a meaningful delimiter - registers an offense with a non-meaningful delimiter - with a non-interpolated heredoc - when using back tick delimiters - registers an offense with a non-meaningful delimiter - does not register an offense with a meaningful delimiter - when using double quoted delimiters - does not register an offense with a meaningful delimiter - registers an offense with a non-meaningful delimiter - when using non-word delimiters - registers an offense - when using single quoted delimiters - does not register an offense with a meaningful delimiter - registers an offense with a non-meaningful delimiter - with an interpolated heredoc - registers an offense with a non-meaningful delimiter - does not register an offense with a meaningful delimiter - with multiple heredocs starting on the same line - registers an offense with a leading non-meaningful delimiter - does not register an offense with meaningful delimiters - registers an offense with a trailing non-meaningful delimiter - when the delimiter contains non-letter characters - does not register an offense when delimiter contains a number - does not register an offense when delimiter contains an underscore - -RuboCop::Cop::Layout::SpaceAroundBlockParameters - when EnforcedStyleInsidePipes is space - registers an offense and corrects block arguments inside Hash#each - registers an offense and corrects extra space before first parameter - registers an offense and corrects multiple spaces before parameter - registers an offense and corrects no space after last parameter - accepts a lambda with spaces in the right places - accepts a block with spaces in the right places - registers an offense and corrects no space after closing pipe - skips lambda without args - skips lambda without parens - registers an offense for no space before first parameter - registers an offense and corrects space with parens at middle - registers an offense and corrects spacing in lambda args - accepts an empty block - accepts a block parameter without preceding space - registers an offense and corrects multiple spaces after last parameter - registers an offense and corrects a lambda for no space after last parameter - accepts line break after closing pipe - registers an offense and corrects a lambda for extra spacebefore first parameter - registers an offense and corrects a lambda for multiple spacesafter last parameter - accepts a block with parameters but no body - registers an offense and corrects missing space before first argument and after last argument - registers an offense and corrects a lambda for no space before first parameter - trailing comma - registers an offense and corrects no space after the last comma - accepts space both before and after the last comma - accepts space after the last comma - when EnforcedStyleInsidePipes is no_space - skips lambda without parens - registers an offense and corrects a lambda for space before first parameter - registers an offense and corrects space after last parameter - registers an offense and corrects no space after closing pipe - registers an offense and corrects a lambda for space after the last parameter - registers an offense and corrects all types of spacing issues - registers an offense and corrects space before first parameter - skips lambda without args - accepts line break after closing pipe - accepts a block parameter without preceding space - accepts a block with spaces in the right places - registers an offense and corrects all types of spacing issues for a lambda - registers an offense and corrects multiple spaces before parameter - accepts an empty block - registers an offense and corrects for space with parens - accepts block parameters with surrounding space that includes line breaks - accepts a block with parameters but no body - accepts a lambda with spaces in the right places - trailing comma - registers an offense for space before and after the last comma - registers an offense for space after the last comma - -RuboCop::Cop::Lint::SymbolConversion - does not register an offense for a normal symbol - does not register an offense for a symbol that requires quotes - does not register an offense for a dstr - behaves like offense - registers an offense for :"foo" - behaves like offense - registers an offense for :foo.to_sym - EnforcedStyle: consistent - hash where there are keys needing quoting - registers an offense for unquoted keys - with a key with = - requires symbols to be quoted - hash where keys are quoted but do not need to be - registers an offense - hash where no keys need to be quoted - does not register an offense - with a mix of string and symbol keys - does not register an offense - with different quote styles - does not register an offense - single quoted symbol - does not register an offense - behaves like offense - registers an offense for "foo-bar".to_sym - inside a percent literal array - does not register an offense - behaves like offense - registers an offense for "foo-bar".intern - behaves like offense - registers an offense for "foo_bar".to_sym - behaves like offense - registers an offense for :foo.intern - in a hash - keys - does not register an offense for a require quoted symbol that ends with `=` - registers an offense for a quoted symbol - does not register an offense for a require quoted symbol that contains `:` - registers and corrects an offense for a quoted symbol that ends with `!` - does not register an offense for a require quoted symbol - does not register an offense for a normal symbol - does not register an offense for operators - registers and corrects an offense for a quoted symbol that ends with `?` - values - registers an offense for a quoted symbol value - registers an offense for a quoted symbol key - does not register an offense for a normal symbol - in an alias - does not register an offense - behaves like offense - registers an offense for "foo_bar".intern - behaves like offense - registers an offense for "foo".to_sym - implicit `to_sym` call - does not register an offense - behaves like offense - registers an offense for :"foo_bar" - behaves like offense - registers an offense for "foo".intern - -RuboCop::Cop::Style::ClassMethodsDefinitions - when EnforcedStyle is self_class - does not register an offense when defining class methods with `class << self` - does not register an offense when defining singleton methods not on self - registers an offense when defining class methods with `def self.method` - when EnforcedStyle is def_self - registers and corrects an offense when defining class methods with `class << self` with comment only body - correctly handles class << self containing multiple methods - registers an offense and corrects when defining class methods with `class << self` - does not register an offense when class << self does not contain methods - does not register an offense when defining class methods with `def self.method` - correctly handles def self.x within class << self - does not register an offense when `class << self` contains non public methods - does not register an offense when class << self contains only class methods - registers and corrects an offense when defining class methods with `class << self` with inline comment - does not register an offense when defining singleton methods using `self << object` - correctly handles methods with annotation comments - removes empty class << self when correcting - registers an offense and corrects when defining class methods with `class << self` and there is no blank line between method definition and attribute accessor - -RuboCop::Cop::Style::NegatedIfElseCondition - registers an offense and corrects nested `if-else` with negated condition - works with comments and multiple statements - registers an offense when using negated condition and `if` branch body is empty - correctly moves comments at the end of branches - does not register an offense when only part of the condition is negated - works with duplicate nodes - does not register an offense when `if` with `!!` condition - does not register an offense when both branches are empty - does not register an offense when `if` with negated condition has no `else` branch - registers an offense and corrects a multiline ternary - moves comments to correct branches during autocorrect - registers an offense and corrects when negating condition with `not` for ternary - works with comments when neither branch is a begin node - registers an offense and corrects when negating condition with `!` for `if-else` - registers an offense and corrects when negating condition with `not` for `if-else` - does not register an offense when negating condition for `if-elsif` - does not register an offense when the `else` branch is empty - works with comments when one branch is a begin and the other is not - behaves like negation method - registers an offense and corrects when negating condition with `!=` in begin-end for ternary - registers an offense and corrects when negating condition with `!=` for ternary - registers an offense and corrects when negating condition with `!=` in parentheses for ternary - registers an offense and corrects when negating condition with `!=` for `if-else` - registers an offense and corrects when negating condition with `!=` in begin-end for `if-else` - registers an offense and corrects when negating condition with `!=` in parentheses for `if-else` - behaves like negation method - registers an offense and corrects when negating condition with `!~` for `if-else` - registers an offense and corrects when negating condition with `!~` in begin-end for `if-else` - registers an offense and corrects when negating condition with `!~` in parentheses for ternary - registers an offense and corrects when negating condition with `!~` in begin-end for ternary - registers an offense and corrects when negating condition with `!~` in parentheses for `if-else` - registers an offense and corrects when negating condition with `!~` for ternary - -RuboCop::Cop::Style::InlineComment - does not register an offense for a standalone comment - does not register an offense for special rubocop inline comments - registers an offense for a trailing inline comment - -RuboCop::Cop::AlignmentCorrector - #correct - with large column deltas - with heredoc in backticks (<<``) - behaves like heredoc indenter - does not change indentation of here doc bodies and end markers - with plain heredoc (<<) - behaves like heredoc indenter - does not change indentation of here doc bodies and end markers - within string literals - does not insert whitespace - simple indentation - with a negative column delta - outdents - with a positive column delta - indents - with single-line here docs - does not indent body and end marker - -RuboCop::Cop::Style::SymbolLiteral - accepts string syntax when symbols have whitespaces in them - accepts string syntax when symbol start with a digit - registers an offense for word-line symbols using string syntax - accepts string syntax when symbols have special chars in them - -RuboCop::Cop::Layout::SpaceInsideParens - when EnforcedStyle is space - accepts empty parentheses without spaces - accepts parentheses with line break - registers an offense for no space around heredoc start - registers an offense for space inside empty parens - accepts parentheses with spaces - registers an offense for no spaces inside parens - accepts parentheses with comment and line break - registers an offense in block parameter list with no spaces - when EnforcedStyle is no_space - accepts parentheses with line break - registers an offense for spaces inside parens - accepts parentheses with comment and line break - accepts parentheses with no spaces - registers an offense for space around heredoc start - accepts parentheses in block parameter list - when EnforcedStyle is compact - accepts two consecutive right parentheses - registers an offense for space between consecutive brackets - accepts parentheses with line break - accepts parentheses with spaces - registers an offense for no space around heredoc start - accepts two consecutive left parentheses - accepts empty parentheses without spaces - registers an offense in block parameter list with no spaces - accepts parentheses with comment and line break - registers an offense for no spaces inside parens - accepts three consecutive right parentheses - registers an offense for space inside empty parens - registers multiple offense for a missing and extra space between consecutive brackets - accepts three consecutive left parentheses - -RuboCop::Cop::Style::NestedFileDirname - Ruby <= 3.0 - does not register an offense when using `File.dirname(path)` nested two times - Ruby >= 3.1 - registers and corrects an offense when using `File.dirname(path)` nested three times - registers and corrects an offense when using `File.dirname(path)` nested two times - does not register an offense when using non nested `File.dirname(path)` - does not register an offense when using `File.dirname(path, 2)` - -RuboCop::Cop::Style::MultilineIfThen - does not get confused by a commented-out then - does not get confused by a then in a when - does not raise an error for an implicit match unless - registers an offense for then in multiline unless - accepts table style if/then/elsif/ends - does not get confused by empty elsif branch - does not raise an error for an implicit match if - registers an offense for then in multiline if - registers an offense for then in multiline elsif - does not get confused by a postfix unless - does not get confused by a nested postfix unless - -RuboCop::CLI --auto-gen-config - --auto-gen-config - generates EnforcedStyle parameter if it solves all offenses - includes --auto-gen-only-exclude in the command comment when given - overwrites an existing todo file - can generate a todo list - can generate Exclude properties with a given limit - generates a todo list that removes the reports - generates Exclude instead of Max when --auto-gen-only-exclude is used - honors rubocop:disable comments - does not include offense counts when --no-offense-counts is used - can be called when there are no files to inspection - does not include a timestamp when --no-auto-gen-timestamp is used - does not generate configuration for the Syntax cop - generates Exclude if no EnforcedStyle solves all offenses - when .rubocop.yml is empty - bases other cops' configuration on the code base's current maximum line length - for existing configuration with Exclude - leaves out Excludes that appear in .rubocop.yml but are merged for the cop - leaves out Excludes that appear in .rubocop.yml but are merged globally - generates Excludes that appear in .rubocop.yml - when .rubocop.yml does not exist - bases other cops' configuration on the code base's current maximum line length - when hash value omission enabled - generates Exclude if it solves all offenses - when .rubocop.yml inherits from another file - bases other cops' configuration on the code base's current maximum line length - when cop is not safe to autocorrect - can generate a todo list, with the appropriate flag - when inheriting from a URL - when there is a single entry - can generate a todo list - when there are multiple entries - can generate a todo list - when different styles appear in different files - disables cop if --exclude-limit is exceeded - generates Exclude list if --exclude-limit is not exceeded - when .rubocop.yml inherits only from .rubocop_todo.yml - bases other cops' configuration on the code base's current maximum line length - when .rubocop.yml inherits from two other files - bases other cops' configuration on the code base's current maximum line length - when .rubocop.yml doesn't inherit - bases other cops' configuration on the code base's current maximum line length - when existing config file has a YAML document start header - inserts `inherit_from` key after hearder - console output - displays report summary but no offenses - when working with a cop who do not support autocorrection - can generate a todo list - when .rubocop.yml inherits from another file and .rubocop_todo.yml - bases other cops' configuration on the code base's current maximum line length - when duplicated default configuration parameter - parameters are displayed without duplication - when working in a subdirectory - can generate a todo list - with Layout/LineLength:Max overridden - when .rubocop.yml has Layout/LineLength:Max more than code base max - bases other cops' configuration on the overridden LineLength:Max - when .rubocop.yml has Layout/LineLength disabled - skips the cop from both phases of the run - when .rubocop.yml has Layout/LineLength:Max less than code base max - bases other cops' configuration on the overridden LineLength:Max - when --config is used - can generate a todo list - can generate a todo list if default .rubocop.yml exists - when --no-exclude-limit is given - always prefers Exclude to Enabled - when .rubocop.yml inherits only from .rubocop_todo.yml in an array - bases other cops' configuration on the code base's current maximum line length - -RuboCop::Cop::Layout::LineLength - accepts the first line if it is a shebang line - highlights excessive characters - registers an offense for a line that's 81 characters wide - accepts a line that's 80 characters wide - registers an offense for long line before __END__ but not after - when AllowedPatterns option is set - only registers an offense for lines not matching the pattern - when AllowHeredoc option is enabled - accepts long lines in heredocs - when the source has no AST - does not crash - and only certain heredoc delimiters are permitted - rejects long lines in heredocs with not permitted delimiters - when IgnoreCopDirectives is enabled - and the source is too long - highlights only the non-directive part - and the source contains non-directive #s as non-comment - registers an offense for the line - and the source contains non-directive # as comment - highlights only the non-directive part - and the Rubocop directive is excessively long - accepts the line - and the Rubocop directive causes an excessive line length - accepts the line - and has explanatory text - does not register an offense - when line is indented with tabs - accepts a short line - registers an offense for a long line - autocorrection - hash - when over limit and already on multiple lines long key - adds an offense and does not autocorrect - when over limit rocket - adds an offense and autocorrects it - when over limit and keys already on multiple lines - adds an offense and does not autocorrect - when over limit - adds an offense and autocorrects it - when over limit rocket symbol - adds an offense and autocorrects it - when under limit - does not add any offenses - when over limit because of a comment - adds an offense and does not autocorrect - when nested hashes on same line - adds an offense only to outer and autocorrects it - when hash in method call - adds an offense only to outer and autocorrects it - HEREDOC - when over limit with semicolon - adds offense and does not autocorrect - semicolon - when over limit and one semicolon at the end - adds offense and does not autocorrectbefore the hash - when under limit - does not add any offenses - when over limit and many semicolons - adds offense and autocorrects it by breaking the semicolonbefore the hash - semicolon inside string literal - adds offense and autocorrects elsewhere - semicolons inside string literal - adds offense and autocorrects elsewhere - when over limit and many semicolons at the end - adds offense and does not autocorrectbefore the hash - when over limit and semicolon at end of line - adds offense and autocorrects it by breaking the first semicolonbefore the hash - when over limit - adds offense and autocorrects it by breaking the semicolonbefore the hash - when over limit and many spaces around semicolon - adds offense and autocorrects it by breaking the semicolonbefore the hash - method definition - when over limit - adds an offense and autocorrects it - when under limit - does not add any offenses - multiple assignment - when over limit at right hand side - registers and corrects an offense - no breakable collections - adds an offense and does not autocorrect it - long blocks - do/end - adds an offense for block without arguments and does correct it - adds an offense for block with arguments and does correct it - let block - adds an offense and does correct it - no spaces - adds an offense and does correct it - lambda syntax - when argument is not enclosed in parentheses - registers an offense and corrects - when argument is enclosed in parentheses - registers an offense and corrects - Ruby 2.7 - adds an offense for do-end block and does correct it - adds an offense for {} block does correct it - braces - adds an offense and does correct it - method call - when unparenthesized - when there is one argument - does not autocorrect - when there are multiple arguments - splits the line after the first element - when under limit - does not add any offenses - when call with hash on same line - adds an offense only to outer and autocorrects it - when nested method calls allows outer to get broken up first - adds offense and does not autocorrect - when two method calls - adds an offense only to outer and autocorrects it - with long argument list - registers an offense and autocorrects it - with a hash with a too long first item - when parenthesized - corrects - when the hash is parenthesized - corrects - when not parenthesized - when on multiple lines - does not correct - when there is only one element - does not autocorrect - when there are multiple elements - moves the 2nd element to a new line - when two together - does not add any offenses - when over limit - adds an offense and autocorrects it - with a heredoc argument - does not break up the line - does not break up the line when a heredoc is used as the first element of an array - does not break up the line when parentheses are omitted - and other arguments before the heredoc - can break up the line before the heredoc argument - and the heredoc is after the line should split - can break up the line before the heredoc argument - array - when two arrays on two lines allows outer to get broken first - adds an offense only to inner and does not autocorrect it - when already on two lines - does not add any offenses - when has inside array - adds an offense only to outer and autocorrects it - when over limit - adds an offense and autocorrects it - when under limit - does not add any offenses - comments - when over limit with semicolon - adds offense and does not autocorrect - when AllowURI option is enabled - and the excessive characters include a complete URL - registers an offense for the line - and the URL fits within the max allowed characters - registers an offense for the line - and the URL does not have a http(s) scheme - rejects the line - and the scheme has been configured +RuboCop::Cop::Style::MutableConstant + Strict: true + allows calls to freeze + freezes a heredoc + behaves like immutable objects + allows 1.5 to be ||= to a constant + allows 1.5 to be assigned to a constant + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + behaves like mutable objects + when assigning with = + registers an offense for Something.new assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for Something.new assigned to a constant and corrects by adding .freeze + when assigning an array without brackets + does not insert brackets for %w() arrays + adds brackets when autocorrecting + behaves like mutable objects + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows OTHER_CONST to be assigned to a constant + allows OTHER_CONST to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ::OTHER_CONST to be assigned to a constant + allows ::OTHER_CONST to be ||= to a constant + behaves like immutable objects + allows Struct.new to be assigned to a constant + allows Struct.new to be ||= to a constant + methods and operators that produce frozen objects + accepts operating on multiple floats + accepts operating on a constant and an interger + accepts checking fixed size + accepts operating on a constant and a float + accepts operating on multiple integers + accepts comparison operators + accepts assigning to an environment variable with a fallback + behaves like immutable objects + allows ::ENV['foo'] to be ||= to a constant + allows ::ENV['foo'] to be assigned to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + operators that produce unfrozen objects + registers an offense when operating on a constant and a string + registers an offense when operating on multiple strings + behaves like string literal + Ruby 3.0 or higher + when the frozen string literal comment is missing + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is true + registers an offense when using interpolated heredoc constant + registers an offense when using a multiline string with interpolation + does not register an offense when using a multiline string + behaves like immutable objects + allows <<~HERE + foo + bar +HERE + to be assigned to a constant + allows <<~HERE + foo + bar +HERE + to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is false + behaves like mutable objects + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + Ruby 2.7 or lower + when the frozen string literal comment is missing + behaves like mutable objects + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is false + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is true + does not register an offense when using a multiline string + does not register an offense when using interpolated heredoc constant + behaves like immutable objects + allows "#{a}" to be assigned to a constant + allows "#{a}" to be ||= to a constant + behaves like immutable objects + allows <<~HERE + foo + bar +HERE + to be ||= to a constant + allows <<~HERE + foo + bar +HERE + to be assigned to a constant + behaves like immutable objects + allows ::Namespace::OTHER_CONST to be assigned to a constant + allows ::Namespace::OTHER_CONST to be ||= to a constant + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like immutable objects + allows ::Struct.new to be ||= to a constant + allows ::Struct.new to be assigned to a constant + when assigning with multiple operator calls + registers an offense and corrects with parens and freeze + behaves like mutable objects + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows Struct.new(:node) do + def assignment? + true + end +end + to be assigned to a constant + allows Struct.new(:node) do + def assignment? + true + end +end + to be ||= to a constant + when assigning with an operator + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like operator methods + registers an offense and corrects with parens and freeze + behaves like immutable objects + allows Struct.new(:a, :b) to be ||= to a constant + allows Struct.new(:a, :b) to be assigned to a constant + behaves like immutable objects + allows Namespace::OTHER_CONST to be assigned to a constant + allows Namespace::OTHER_CONST to be ||= to a constant + splat expansion + expansion of a range + registers an offense and corrects to use to_a.freeze + with parentheses + registers an offense and corrects to use to_a.freeze + Strict: false + allows method call assignments + behaves like immutable objects + allows 1.5 to be assigned to a constant + allows 1.5 to be ||= to a constant + splat expansion + expansion of a range + registers an offense and corrects to use to_a.freeze + with parentheses + registers an offense and corrects to use to_a.freeze + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + Ruby 3.0 or higher + raises offense only for shareable_constant_value as none when set in the order of: literal, none and experimental_everything + raises offense when shareable_constant_value is specified as an inline comment + when assigning a range (erange) + does not register an offense when with parenthesis + does not register an offense when without parenthesis + when assigning a range (irange) + does not register an offense when with parenthesis + does not register an offense when without parenthesis + when assigning a regexp does not register an offense - and the excessive characters include part of a URL and trailing whitespace - registers an offense for the line - and the URI is assigned - does not register an offense - and the URI is an argument - does not register an offense - and the excessive characters include part of a URL in braces and another word - registers an offense for the line - and all the excessive characters are part of a URL - accepts the line - and the URL is wrapped in braces with title - accepts the line - and the URL is wrapped in double quotes - accepts the line - and the URL is wrapped in single quotes - accepts the line - and the URL is wrapped in braces - accepts the line - and an error other than URI::InvalidURIError is raised while validating a URI-ish string - does not crash - and the excessive characters include part of a URL and another word - registers an offense for the line - and the excessive characters include part of a URL in double quotes - does not include the quote as part of the offense - when IgnoreCopDirectives is disabled - and the source is too long and has a trailing cop directive - highlights the excess source and cop directive - and the source is acceptable length - with a trailing RuboCop directive - registers an offense for the line - with an inline comment - highlights the excess comment - when AllowURI option is disabled - and all the excessive characters are part of a URL - registers an offense for the line - affecting by IndentationWidth from Layout\Tab - without AllowURI option - behaves like with tabs indentation - registers an offense for a line that's including 2 tab with size 2 and 28 other characters - accepts a line that's including 1 tab with size 2 and 28 other characters - with AllowURI option - accepts a line that's including URI in quotes with text - accepts a line that's including URI with text - accepts a line that's including URI - accepts a line that's including URI and exceeds by 1 char - behaves like with tabs indentation - registers an offense for a line that's including 2 tab with size 2 and 28 other characters - accepts a line that's including 1 tab with size 2 and 28 other characters - -RuboCop::Cop::Style::MultilineMethodSignature - when arguments span multiple lines - when correction would not exceed maximum line length - registers an offense and corrects - when defining an class method - registers an offense and corrects when `end` is on the same line - registers an offense and corrects when `end` is on the following line - registers an offense and corrects when `end` is on the same line with only closing parentheses - when correction would exceed maximum line length - does not register an offense - when defining an instance method - registers an offense and corrects when `end` is on the following line - registers an offense and corrects when `end` is on the same line with last argument - registers an offense and corrects when `end` is on the same line with only closing parentheses - when arguments span a single line - when defining an instance method - registers an offense and corrects when closing paren is on the following line - registers an offense and corrects when line break after opening parenthesis - when method signature is on a single line - does not register an offense for parameterized method - does not register an offense for unparameterized method - when defining an class method - when method signature is on a single line - does not register an offense for unparameterized method - does not register an offense for parameterized method - when arguments span a single line - registers an offense and corrects when closing paren is on the following line - -RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault - when EnforcedStyle is space - registers an offense and corrects missing space for arguments with unary operators - registers an offense and corrects default value assignment where first is partially right without space - registers an offense and corrects assigning empty string without space - accepts default value assignment with space - registers an offense and corrects assignment of empty list without space - registers an offense and corrects default value assignment without space - accepts default value assignment with spaces and unary + operator - when EnforcedStyle is no_space - registers an offense and corrects assignment of empty list with space - accepts default value assignment without space - registers an offense and corrects assignment of empty string with space - registers an offense and corrects default value assignment with space + when using shareable_constant_value + behaves like literals that are frozen + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like immutable objects + allows FOO + BAR to be ||= to a constant + allows FOO + BAR to be assigned to a constant + behaves like immutable objects + allows { a: 1, b: 2 } to be ||= to a constant + allows { a: 1, b: 2 } to be assigned to a constant + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows %w(a b c) to be assigned to a constant + allows %w(a b c) to be ||= to a constant + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like immutable objects + allows "top#{1 + 2}" to be ||= to a constant + allows "top#{1 + 2}" to be assigned to a constant + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + behaves like immutable objects + allows 1.5 to be ||= to a constant + allows 1.5 to be assigned to a constant + behaves like immutable objects + allows [1, 2, 3] to be assigned to a constant + allows [1, 2, 3] to be ||= to a constant + behaves like immutable objects + allows 'str' to be assigned to a constant + allows 'str' to be ||= to a constant + behaves like literals that are frozen + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like immutable objects + allows :sym to be ||= to a constant + allows :sym to be assigned to a constant + behaves like immutable objects + allows [1, 2, 3] to be assigned to a constant + allows [1, 2, 3] to be ||= to a constant + behaves like immutable objects + allows "top#{1 + 2}" to be assigned to a constant + allows "top#{1 + 2}" to be ||= to a constant + behaves like immutable objects + allows 1.5 to be assigned to a constant + allows 1.5 to be ||= to a constant + behaves like immutable objects + allows { a: 1, b: 2 } to be assigned to a constant + allows { a: 1, b: 2 } to be ||= to a constant + behaves like immutable objects + allows ENV['foo'] to be assigned to a constant + allows ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows 'str' to be ||= to a constant + allows 'str' to be assigned to a constant + behaves like immutable objects + allows FOO + BAR to be assigned to a constant + allows FOO + BAR to be ||= to a constant + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like immutable objects + allows ::ENV['foo'] to be ||= to a constant + allows ::ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + behaves like immutable objects + allows %w(a b c) to be ||= to a constant + allows %w(a b c) to be assigned to a constant + behaves like literals that are frozen + behaves like immutable objects + allows 1.5 to be ||= to a constant + allows 1.5 to be assigned to a constant + behaves like immutable objects + allows FOO + BAR to be ||= to a constant + allows FOO + BAR to be assigned to a constant + behaves like immutable objects + allows 'str' to be assigned to a constant + allows 'str' to be ||= to a constant + behaves like immutable objects + allows :sym to be ||= to a constant + allows :sym to be assigned to a constant + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like immutable objects + allows %w(a b c) to be assigned to a constant + allows %w(a b c) to be ||= to a constant + behaves like immutable objects + allows { a: 1, b: 2 } to be assigned to a constant + allows { a: 1, b: 2 } to be ||= to a constant + behaves like immutable objects + allows 1 to be ||= to a constant + allows 1 to be assigned to a constant + behaves like immutable objects + allows FOO - BAR to be ||= to a constant + allows FOO - BAR to be assigned to a constant + behaves like immutable objects + allows "top#{1 + 2}" to be ||= to a constant + allows "top#{1 + 2}" to be assigned to a constant + behaves like immutable objects + allows [1, 2, 3] to be assigned to a constant + allows [1, 2, 3] to be ||= to a constant + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like literals that are not frozen + behaves like immutable objects + allows 1 to be ||= to a constant + allows 1 to be assigned to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like mutable objects + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows FOO + BAR to be ||= to a constant + allows FOO + BAR to be assigned to a constant + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like immutable objects + allows :sym to be ||= to a constant + allows :sym to be assigned to a constant + behaves like mutable objects + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 1.5 to be assigned to a constant + allows 1.5 to be ||= to a constant + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like string literal + Ruby 2.7 or lower + when the frozen string literal comment is false + behaves like mutable objects + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is true + does not register an offense when using a multiline string + does not register an offense when using interpolated heredoc constant + behaves like immutable objects + allows "#{a}" to be assigned to a constant + allows "#{a}" to be ||= to a constant + behaves like immutable objects + allows <<~HERE + foo + bar +HERE + to be assigned to a constant + allows <<~HERE + foo + bar +HERE + to be ||= to a constant + when the frozen string literal comment is missing + behaves like mutable objects + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + Ruby 3.0 or higher + when the frozen string literal comment is missing + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when the frozen string literal comment is true + registers an offense when using a multiline string with interpolation + does not register an offense when using a multiline string + registers an offense when using interpolated heredoc constant + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows <<~HERE + foo + bar +HERE + to be assigned to a constant + allows <<~HERE + foo + bar +HERE + to be ||= to a constant + when the frozen string literal comment is false + behaves like mutable objects + when assigning with ||= + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "#{a}" assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ENV['foo'] to be assigned to a constant + allows ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows FOO - BAR to be ||= to a constant + allows FOO - BAR to be assigned to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + Ruby 2.7 or lower + when assigning a range (irange) without parenthesis + adds parentheses when autocorrecting + does not insert parenthesis to range enclosed in parentheses + when assigning a regexp + registers an offense + when assigning a range (erange) without parenthesis + does not insert parenthesis to range enclosed in parentheses + adds parentheses when autocorrecting + when using shareable_constant_values + behaves like literals that are not frozen + behaves like mutable objects + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like immutable objects + allows FOO + BAR to be ||= to a constant + allows FOO + BAR to be assigned to a constant + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like immutable objects + allows 'foo' + 'bar' to be assigned to a constant + allows 'foo' + 'bar' to be ||= to a constant + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + behaves like immutable objects + allows 1.5 to be ||= to a constant + allows 1.5 to be assigned to a constant + behaves like mutable objects + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like immutable objects + allows ::ENV['foo'] to be ||= to a constant + allows ::ENV['foo'] to be assigned to a constant + behaves like literals that are not frozen + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ENV['foo'] to be assigned to a constant + allows ENV['foo'] to be ||= to a constant + behaves like mutable objects + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows 1 to be assigned to a constant + allows 1 to be ||= to a constant + behaves like immutable objects + allows FOO + BAR to be assigned to a constant + allows FOO + BAR to be ||= to a constant + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like immutable objects + allows 1.5 to be assigned to a constant + allows 1.5 to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like literals that are not frozen + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like mutable objects + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows :sym to be ||= to a constant + allows :sym to be assigned to a constant + behaves like immutable objects + allows ENV['foo'] to be assigned to a constant + allows ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows 1 to be ||= to a constant + allows 1 to be assigned to a constant + behaves like mutable objects + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 1.5 to be ||= to a constant + allows 1.5 to be assigned to a constant + behaves like mutable objects + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows FOO + BAR to be assigned to a constant + allows FOO + BAR to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + behaves like literals that are not frozen + behaves like immutable objects + allows 'foo' + 'bar' to be assigned to a constant + allows 'foo' + 'bar' to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for %w(a b c) assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with = + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for { a: 1, b: 2 } assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows FOO + BAR to be assigned to a constant + allows FOO + BAR to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for 'str' assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows ::ENV['foo'] to be assigned to a constant + allows ::ENV['foo'] to be ||= to a constant + behaves like immutable objects + allows ENV['foo'] to be ||= to a constant + allows ENV['foo'] to be assigned to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows FOO - BAR to be assigned to a constant + allows FOO - BAR to be ||= to a constant + behaves like immutable objects + allows 1 to be ||= to a constant + allows 1 to be assigned to a constant + behaves like immutable objects + allows :sym to be assigned to a constant + allows :sym to be ||= to a constant + behaves like immutable objects + allows 1.5 to be assigned to a constant + allows 1.5 to be ||= to a constant + behaves like mutable objects + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like immutable objects + allows FOO + BAR to be assigned to a constant + allows FOO + BAR to be ||= to a constant + behaves like immutable objects + allows 'foo' + 'bar' to be ||= to a constant + allows 'foo' + 'bar' to be assigned to a constant + when assigning an array without brackets + adds brackets when autocorrecting + does not insert brackets for %w() arrays + behaves like mutable objects + when assigning with ||= + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + when assigning with = + registers an offense for "top#{1 + 2}" assigned to a constant and corrects by adding .freeze + behaves like mutable objects + when assigning with = + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze + when assigning with ||= + registers an offense for [1, 2, 3] assigned to a constant and corrects by adding .freeze -RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment - behaves like deprecated attributes - registers and corrects an offense when using `spec.rubygems_version =` - registers and corrects an offense when using `s.rubygems_version =` - does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` - does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable - behaves like deprecated attributes - does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` - registers and corrects an offense when using `s.rubygems_version =` - does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable - registers and corrects an offense when using `spec.rubygems_version =` - behaves like deprecated attributes with addition - registers and corrects an offense when using `spec.rubygems_version +=` - registers and corrects an offense when using `s.rubygems_version +=` - behaves like deprecated attributes - registers and corrects an offense when using `spec.rubygems_version =` - does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` - does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable - registers and corrects an offense when using `s.rubygems_version =` - behaves like deprecated attributes - does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` - does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable - registers and corrects an offense when using `s.rubygems_version =` - registers and corrects an offense when using `spec.rubygems_version =` +RuboCop::Cop::Style::RedundantSelfAssignmentBranch + does not register an offense when self-assigning redundant else ternary branch for ivar + registers and corrects an offense when self-assigning redundant else branch + registers and corrects an offense when self-assigning redundant if branch + does not register an offense when self-assigning redundant else ternary branch for gvar + does not register an offense when not self-assigning redundant branches + does not register an offense when self-assigning redundant else ternary branch for cvar + does not register an offense when multi assignment + registers and corrects an offense when self-assigning redundant else branch and empty if branch + does not register an offense when using `elsif` and self-assigning the value of `then` branch + does not register an offense when using `elsif` and self-assigning the value of `else` branch + does not register an offense when self-assigning redundant else branch and multiline if branch + does not register an offense when self-assigning redundant else branch and multiline else branch + registers and corrects an offense when self-assigning redundant else branch and empty else branch + registers and corrects an offense when self-assigning redundant if ternary branch + does not register an offense when using `elsif` and self-assigning the value of `elsif` branch + registers and corrects an offense when self-assigning redundant else ternary branch + does not register an offense when lhs is not variable + does not register an offense when using only if branch -RuboCop::Cop::Style::RandomWithOffset - does not register an offense when using range with double dots - registers an offense when using rand(int) - offset - does not register an offense when using range with triple dots - registers an offense when using rand(erange) - offset - registers an offense when using rand(irange).succ - registers an offense when using rand(irange) + offset - registers an offense when using Random.rand - registers an offense when using rand(int).next - registers an offense when using offset + Random.rand(int) - registers an offense when using Kernel.rand - registers an offense when using rand(irange) - offset - registers an offense when using offset - rand(erange) - registers an offense when using rand(int).succ - registers an offense when using offset - rand(int) - registers an offense when using Random.rand(int).succ - does not register an offense when using rand(erange).pred with a non-integer range value - registers an offense when using rand(int).pred - registers an offense when using rand(erange) + offset - registers an offense when using ::Random.rand - registers an offense when using rand(erange).succ - registers an offense when using offset - rand(irange) - does not register an offense when using rand(irange).succ with a non-integer range value - does not register an offense when using offset - rand(erange) with a non-integer range value - registers an offense when using offset + rand(int) - registers an offense when using rand(int) + offset - registers an offense when using ::Kernel.rand - does not register an offense when using rand(irange) + offset with a non-integer range value - registers an offense when using ::Random.rand(int).pred - registers an offense when using offset - ::Random.rand(int) +RuboCop::Cop::InternalAffairs::RedundantMethodDispatchNode + registers an offense when using `node.send_node.method_name` + does not register an offense when using `node.send_node.arguments?` + registers an offense when using `node.send_node.receiver` + does not register an offense when using `node.receiver` + does not register an offense when using `send_node.method_name` + does not register an offense when using `node.method_name` -RuboCop::Cop::Style::OptionalArguments - registers an offense when an optional argument is followed by a required argument - allows methods with multiple optional arguments at the end - allows methods with only one optional argument - allows methods with only required arguments - allows methods with only optional arguments - allows methods with only one required argument - allows methods without arguments - registers an offense for each optional argument when multiple optional arguments are followed by a required argument - named params - required params - allows optional arguments before required named arguments - registers an offense for optional arguments that come before required arguments where there are name arguments - allows optional arguments to come before a mix of required and optional named argument - with default values - allows optional arguments before an optional named argument +RuboCop::Cop::Lint::RedundantRequireStatement + registers an offense when using requiring `enumerator` in condition + registers an offense when using requiring `enumerator` + registers an offense when using requiring `enumerator` with modifier form + target ruby version >= 3.1 + registers an offense and corrects when using requiring `fiber` or already redundant features + target ruby version >= 3.2 + registers an offense and corrects when using requiring `set` + target ruby version < 3.1 + does not register an offense and corrects when using requiring `fiber` + target ruby version >= 2.7 + registers an offense when using requiring `ruby2_keywords` or already redundant features + target ruby version <= 2.6 + does not register an offense when using requiring `ruby2_keywords` + target ruby version <= 2.0 + does not register an offense when using requiring `thread` + target ruby version <= 2.1 + does not register an offense when using requiring `rational`, `complex` + target ruby version >= 2.5 + register an offense and corrects when using requiring `pp` or already redundant features + target ruby version >= 2.1 + register an offense and corrects when using requiring `thread` or already redundant features + target ruby version <= 2.4 + does not register an offense when using requiring `pp` + target ruby version >= 2.2 + registers an offense when using requiring `rational`, `complex` -RuboCop::Cop::Lint::DuplicateBranch - registers an offense when `rescue` has duplicate `else` branch - does not register an offense for simple `if` without other branches - registers an offense when `case` has duplicate `when` branch - registers an offense when ternary has duplicate branches - registers an offense when `case` has duplicate `else` branch - registers an offense when `case` has multiple duplicate branches - does not register an offense for empty `unless` - registers an offense when `rescue` has duplicate `resbody` branch - does not register an offense for modifier `if` - does not register an offense when `unless` has no duplicate branches - registers an offense when `if` has duplicate `else` branch - does not register an offense when `if` has no duplicate branches - does not register an offense when `rescue` has no duplicate branches - does not register an offense for empty `if` - registers an offense when `unless` has duplicate `else` branch - does not register an offense for simple `unless` without other branches - does not register an offense for modifier `unless` - does not register an offense when ternary has no duplicate branches - registers an offense when `if` has multiple duplicate branches - registers an offense when `rescue` has multiple duplicate `resbody` branches - registers an offense when `if` has duplicate `elsif` branch - does not register an offense when `case` has no duplicate branches - with IgnoreLiteralBranches: true - with `rescue` - behaves like literal rescue allowed - when returning a regexp in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a hash of literals in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a simple erange in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a simple irange in multiple branches - allows branches to be duplicated - and IgnoreConstBranches: false - behaves like literal rescue disallowed - when returning a array of constants in multiple branches - registers an offense - behaves like literal rescue disallowed - when returning a hash of constants in multiple branches +RuboCop::Cop::Style::DocumentationMethod + when declaring methods outside a class + when declaring methods in a module + without documentation comment + when method is private + does not register an offense with inline `private` and `end` + does not register an offense with inline `private` + does not register an offense + does not register an offense with `end` on the same line + when required for non-public methods + registers an offense with inline `private` and `end` + registers an offense with inline `private` + registers an offense with `end` on the same line registers an offense - behaves like literal rescue allowed - when returning a empty array in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a complex array in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a true in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a dstr in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a string in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a array of literals in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a variable in multiple branches - registers an offense - behaves like literal rescue disallowed - when returning a xstr in multiple branches - registers an offense - and IgnoreConstBranches: true - behaves like literal rescue allowed - when returning a array of constants in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a hash of constants in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a complex regexp in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a complex in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a regexp with modifier in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a symbol in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a dsym in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a float in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a complex hash in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a nil in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a complex erange in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a false in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a complex irange in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a integer in multiple branches - allows branches to be duplicated - behaves like literal rescue allowed - when returning a rational in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a method call in multiple branches - registers an offense - behaves like literal rescue allowed - when returning a empty hash in multiple branches - allows branches to be duplicated - with `if` - behaves like literal if disallowed - when returning a method call in multiple branches - registers an offense - behaves like literal if disallowed - when returning a complex hash in multiple branches - registers an offense - behaves like literal if allowed - when returning a integer in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a rational in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a empty array in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a empty hash in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a float in multiple branches - allows branches to be duplicated - and IgnoreConstBranches: true - behaves like literal if allowed - when returning a array of constants in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a hash of constants in multiple branches - allows branches to be duplicated - behaves like literal if disallowed - when returning a variable in multiple branches - registers an offense - behaves like literal if disallowed - when returning a complex array in multiple branches - registers an offense - behaves like literal if allowed - when returning a simple irange in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a hash of literals in multiple branches - allows branches to be duplicated - behaves like literal if disallowed - when returning a dstr in multiple branches + when method is public + registers an offense with `end` on the same line registers an offense - behaves like literal if allowed - when returning a regexp in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a nil in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a regexp with modifier in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a true in multiple branches - allows branches to be duplicated - behaves like literal if disallowed - when returning a xstr in multiple branches + when method is module_function + registers an offense for inline def + registers an offense for separate def + with both public and private methods + when required for non-public methods registers an offense - behaves like literal if disallowed - when returning a complex erange in multiple branches + when the public method has documentation + does not register an offense + when the public method has no documentation registers an offense - behaves like literal if disallowed - when returning a complex regexp in multiple branches + with documentation comment + when method is module_function + does not register an offense for inline def + does not register an offense for separate def + when method is public + does not register an offense with `end` on the same line + does not register an offense + with documentation comment + does not register an offense + does not register an offense with `end` on the same line + without documentation comment + when method is private + does not register an offense with inline `private` and `end` + does not register an offense with inline `private` + does not register an offense + does not register an offense with `end` on the same line + when required for non-public methods + registers an offense with `end` on the same line + registers an offense with inline `private` + registers an offense with inline `private` and `end` registers an offense - behaves like literal if disallowed - when returning a dsym in multiple branches + when method is public + registers an offense + registers an offense with `end` on the same line + registers an offense when method is public, but there were private methods before + when method is protected + does not register an offense with inline `protected` + does not register an offense + when required for non-public methods registers an offense - behaves like literal if allowed - when returning a simple erange in multiple branches - allows branches to be duplicated - and IgnoreConstBranches: false - behaves like literal if disallowed - when returning a hash of constants in multiple branches + registers an offense with inline `protected` + when declaring methods for class instance + with documentation comment + does not register an offense with `end` on the same line + does not register an offense + with both public and private methods + when the public method has no documentation registers an offense - behaves like literal if disallowed - when returning a array of constants in multiple branches + when the public method has documentation + does not register an offense + when required for non-public methods registers an offense - behaves like literal if allowed - when returning a symbol in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a false in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a array of literals in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a string in multiple branches - allows branches to be duplicated - behaves like literal if allowed - when returning a complex in multiple branches - allows branches to be duplicated - behaves like literal if disallowed - when returning a complex irange in multiple branches - registers an offense - with `case` - behaves like literal case allowed - when returning a simple erange in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a complex in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a complex hash in multiple branches - registers an offense - behaves like literal case allowed - when returning a regexp in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a dstr in multiple branches - registers an offense - behaves like literal case allowed - when returning a array of literals in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a variable in multiple branches - registers an offense - behaves like literal case allowed - when returning a symbol in multiple branches - allows branches to be duplicated - and IgnoreConstBranches: true - behaves like literal case allowed - when returning a hash of constants in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a array of constants in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a complex irange in multiple branches - registers an offense - behaves like literal case disallowed - when returning a complex array in multiple branches - registers an offense - behaves like literal case allowed - when returning a regexp with modifier in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a true in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a nil in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a hash of literals in multiple branches - allows branches to be duplicated - and IgnoreConstBranches: false - behaves like literal case disallowed - when returning a array of constants in multiple branches + when method is private + does not register an offense with inline `private` and `end` + does not register an offense with `end` on the same line + does not register an offense + does not register an offense with inline `private` + when required for non-public methods + registers an offense with inline `private` and `end` + registers an offense with inline `private` registers an offense - behaves like literal case disallowed - when returning a hash of constants in multiple branches + registers an offense with `end` on the same line + without documentation comment + registers an offense + registers an offense with `end` on the same line + with both public and private methods + when required for non-public methods + registers an offense + when the public method has no documentation + registers an offense + when the public method has documentation + does not register an offense + when declaring methods in a class + without documentation comment + when method is private + does not register an offense with inline `private` and `end` + does not register an offense with inline `private` + does not register an offense + does not register an offense with `end` on the same line + when required for non-public methods + registers an offense with `end` on the same line + registers an offense with inline `private` + registers an offense with inline `private` and `end` registers an offense - behaves like literal case allowed - when returning a integer in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a xstr in multiple branches - registers an offense - behaves like literal case allowed - when returning a false in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a simple irange in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a empty array in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a float in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a rational in multiple branches - allows branches to be duplicated - behaves like literal case allowed - when returning a string in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a dsym in multiple branches - registers an offense - behaves like literal case disallowed - when returning a complex erange in multiple branches - registers an offense - behaves like literal case disallowed - when returning a method call in multiple branches - registers an offense - behaves like literal case allowed - when returning a empty hash in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a complex regexp in multiple branches - registers an offense - with IgnoreConstantBranches: true - with `case` - behaves like literal case allowed - when returning a constant in multiple branches - allows branches to be duplicated - behaves like literal case disallowed - when returning a object in multiple branches - registers an offense - with `rescue` - behaves like literal rescue allowed - when returning a constant in multiple branches - allows branches to be duplicated - behaves like literal rescue disallowed - when returning a object in multiple branches + when method is public + registers an offense with `end` on the same line registers an offense - with `if` - behaves like literal if allowed - when returning a constant in multiple branches - allows branches to be duplicated - behaves like literal if disallowed - when returning a object in multiple branches + with annotation comment + registers an offense + with documentation comment + when method is public + does not register an offense with `end` on the same line + does not register an offense + with both public and private methods + when required for non-public methods registers an offense - with `case-match` - behaves like literal case-match disallowed - when returning a object in multiple branches + when the public method has documentation + does not register an offense + when the public method has no documentation registers an offense - behaves like literal case-match allowed - when returning a constant in multiple branches - allows branches to be duplicated + with directive comment + registers an offense -RuboCop::Cop::Layout::SpaceInsideBlockBraces - registers an offense and corrects left brace without inner space - registers an offense and corrects right brace without inner space - registers an offense and corrects both left and right brace without inner space after success - register offenses and correct both braces without inner space - accepts left brace without outer space - accepts braces surrounded by spaces - configured with no_space - registers an offense and corrects both left and right brace with inner space after success - accepts left brace without outer space - registers an offense and corrects left brace with inner space - registers an offense and corrects right brace with inner space - accepts braces without spaces inside - with passed in parameters - and space before block parameters allowed - accepts left brace with inner space - registers an offense and corrects left brace without inner space - accepts new lambda syntax - and space before block parameters not allowed - accepts new lambda syntax - registers an offense and corrects left brace with inner space - accepts when braces are aligned in multiline block - registers an offense when braces are not aligned in multiline block - registers an offense when braces are not aligned in multiline block with bracket - accepts when braces are aligned in multiline block with bracket - with invalid value for EnforcedStyleForEmptyBraces - fails with an error - with space inside empty braces not allowed - registers an offense and corrects empty braces with space inside - accepts multiline braces with content - accepts braces with something inside - accepts braces that are not empty - accepts empty braces with no space inside - accepts empty braces with comment and line break inside - accepts empty braces with line break inside - with passed in parameters - accepts new lambda syntax - and space before block parameters not allowed - registers an offense and corrects left brace with inner space - accepts new lambda syntax - accepts left brace without inner space - for multi-line blocks - registers an offense and corrects left brace without inner space - accepts left brace with inner space - and BlockDelimiters cop enabled - registers an offense and corrects for single-line blocks - registers an offense and corrects multi-line blocks - for single-line blocks - accepts left brace with inner space - registers an offense and corrects left brace without inner space - Ruby >= 2.7 - registers an offense for numblocks without inner space - with space inside empty braces allowed - registers an offense and corrects empty braces with no space inside - accepts empty braces with space inside +RuboCop::Formatter::AutoGenConfigFormatter + #finished + calls #report_summary + when any offenses are detected + does not report offenses + outputs report summary + when no offenses are detected + does not report offenses + #report_file_as_mark + when different severity offenses are detected + prints highest level mark + when a refactor severity offense is detected + prints "R" + when a refactor convention offense is detected + prints "C" + when no offenses are detected + prints "." -RuboCop::Cop::Style::ZeroLengthPredicate - when inspecting a File::Stat object - does not register an offense with ::File - does not register an offense - with strings - registers an offense for `string.size != 0` - registers an offense for `0 != string.size` - registers an offense for `string.size == 0` - registers an offense for `0 == string.size` - with hashes - registers an offense for `hash.size == 0` - registers an offense for `0 == hash.size - registers an offense for `hash.size != 0` - registers an offense for `0 != hash.size` - when name of the variable is `size` or `length` - accepts equality check - accepts inequality check - accepts comparison - when inspecting a StringIO object - when initialized with a string +RuboCop::Cop::Style::NestedModifier + registers one offense for more than two modifiers + autocorrects unless + unless + does not add redundant parentheses in autocorrection + autocorrects unless with a comparison operator + if + autocorrects unless + if + adds parentheses when needed in autocorrection + autocorrects if + if + autocorrects if + unless + adds parentheses to method arguments when needed in autocorrection + until + behaves like not correctable + does not autocorrect when until is the inner modifier + does not autocorrect when until is the outer modifier + while + behaves like not correctable + does not autocorrect when while is the outer modifier + does not autocorrect when while is the inner modifier + +RuboCop::Cop::Style::EmptyCaseCondition + given a case statement with an empty case + when using `return` in `when` clause and assigning the return value of `case` does not register an offense - does not register an offense with top-level ::StringIO - when initialized without arguments - does not register an offense with top-level ::StringIO + with a single when branch and an else + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + with multiple when branches and no else + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + with a single when branch and no else + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + when using `return ... if` in `else` clause and assigning the return value of `case` does not register an offense - with arrays - registers an offense for `array.size < 1` - registers an offense for `array.length > 0` - registers an offense for `array.size > 0` - registers an offense for `array.size == 0` - registers an offense for `0 == array.size` - registers an offense for `array.length != 0` - registers an offense for `array.length == 0` - registers an offense for `array.size != 0` - registers an offense for `1 > array.size` - registers an offense for `0 == array.length` - registers an offense for `array.length < 1` - registers an offense for `1 > array.length` - registers an offense for `0 < array.size` - registers an offense for `0 < array.length - registers an offense for `0 != array.size` - registers an offense for `0 != array.length` - when inspecting a Tempfile object - does not register an offense with top-level ::Tempfile - does not register an offense - with collection variables - registers an offense for `0 != collection.size` - registers an offense for `collection.size != 0` - registers an offense for `collection.size == 0` - registers an offense for `0 == collection.size` - -RuboCop::Cop::Lint::BinaryOperatorWithIdenticalOperands - registers an offense for `<=` with duplicate operands - registers an offense for `|` with duplicate operands - registers an offense for `>=` with duplicate operands - registers an offense for `&&` with duplicate operands - registers an offense for `===` with duplicate operands - registers an offense for `=~` with duplicate operands - does not register an offense for `*` with duplicate operands - does not crash on operator without any argument - registers an offense for `!=` with duplicate operands - does not register an offense for `+` with duplicate operands - registers an offense for `%` with duplicate operands - does not register an offense when using arithmetic operator with numerics - does not register an offense for `>>` with duplicate operands - registers an offense for `<=>` with duplicate operands - does not register an offense for `<<` with duplicate operands - registers an offense for `==` with duplicate operands - registers an offense for `||` with duplicate operands - registers an offense for `/` with duplicate operands - registers an offense for `^` with duplicate operands - registers an offense for `-` with duplicate operands - registers an offense for `<` with duplicate operands - does not register an offense when using binary operator with different operands - does not register an offense for `**` with duplicate operands - registers an offense for `>` with duplicate operands - -RuboCop::Formatter::EmacsStyleFormatter - #finished - does not report summary - #file_finished - displays parsable text - when the offense is automatically corrected - prints [Corrected] along with message - when the offense message contains a newline - strips newlines out of the error message - when the offense is marked as todo - prints [Todo] along with message - -RuboCop::Cop::Layout::LineContinuationSpacing - EnforcedStyle: no_space - ignores when too much space in front of backslash after `__END__` - registers an offense when many spaces in front of backslash - ignores empty code - registers an offense when one space in front of backslash - marks the offense correctly when offense is not in first line - ignores heredocs and comments - registers no offense with zero spaces in front of backslash - EnforcedStyle: space - marks the offense correctly when offense is not in first line - registers an offense when too much space in front of backslash - registers an offense when no space in front of backslash - ignores heredocs and comments - ignores when too much space in front of backslash after `__END__` - ignores empty code - registers no offense with one space in front of backslash + when using `when ... then` in `case` in `return` + behaves like detect/correct empty case, accept non-empty case + registers an offense and autocorrects + accepts the source with case + when using `return` in `else` clause and assigning the return value of `case` + does not register an offense + with when branches using then + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + when using `when ... then` in `case` in a method call + behaves like detect/correct empty case, accept non-empty case + registers an offense and autocorrects + accepts the source with case + with multiple when branches and an `else` with code comments + behaves like detect/correct empty case, accept non-empty case + registers an offense and autocorrects + accepts the source with case + with a when branch including comma-delimited alternatives + behaves like detect/correct empty case, accept non-empty case + registers an offense and autocorrects + accepts the source with case + when using `return ... if` in `when` clause and assigning the return value of `case` + does not register an offense + with first when branch including comma-delimited alternatives + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + with multiple when branches and an else + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects + when used as an argument of a method without comment + behaves like detect/correct empty case, accept non-empty case + registers an offense and autocorrects + accepts the source with case + when used as an argument of a method with comment + behaves like detect/correct empty case, accept non-empty case + accepts the source with case + registers an offense and autocorrects -RuboCop::Cop::Layout::FirstArgumentIndentation - when EnforcedStyle is consistent - when indentation width is overridden for this cop only - accepts a correctly indented first argument - registers an offense and corrects an over-indented first argument - for method calls within method calls - registers an offense and corrects an over-indented first argument - accepts first argument indented relative to previous line - when IndentationWidth:Width is 2 - does not view []= as an outer method call - registers an offense and corrects an over-indented first argument on a plus sign method name - registers an offense and corrects an over-indented first argument on an alphanumeric method name - registers an offense and corrects an under-indented first argument - registers an offense and corrects an over-indented first argument on a pipe method name - does not view chained call as an outer method call - registers an offense and corrects an over-indented first argument of `super` - accepts operator calls - registers an offense and corrects lines affected by another offense - accepts a first argument that is not preceded by a line break - accepts method calls with no arguments - registers an offense and corrects an over-indented first argument - for assignment - accepts a correctly indented first argument and does not care about the second argument - with line break - registers an offense and corrects an under-indented first argument - accepts a correctly indented first argument - when the receiver contains a line break - accepts a correctly indented first argument preceded by an empty line - accepts a correctly indented first argument - registers an offense and corrects an over-indented first argument - when preceded by a comment line - accepts a correctly indented first argument - registers an offense and corrects an under-indented first argument - when using safe navigation operator - registers an offense and corrects an under-indented 1st argument - for a setter call - accepts an unindented value - when IndentationWidth:Width is 4 - registers an offense and corrects an over-indented first argument - when EnforcedStyle is special_for_inner_method_call_in_parentheses - when IndentationWidth:Width is 2 - registers an offense and corrects an over-indented first argument of `super` - registers an offense and corrects lines affected by another offense - registers an offense and corrects an over-indented first argument - registers an offense and corrects an over-indented first argument on a pipe method name - does not view []= as an outer method call - accepts method calls with no arguments - accepts a first argument that is not preceded by a line break - registers an offense and corrects an under-indented first argument - registers an offense and corrects an over-indented first argument on a plus sign method name - registers an offense and corrects an over-indented first argument on an alphanumeric method name - does not view chained call as an outer method call - accepts operator calls - for assignment - accepts a correctly indented first argument and does not care about the second argument - with line break - registers an offense and corrects an under-indented first argument - accepts a correctly indented first argument - for a setter call - accepts an unindented value - when the receiver contains a line break - accepts a correctly indented first argument preceded by an empty line - accepts a correctly indented first argument - registers an offense and corrects an over-indented first argument - when preceded by a comment line - registers an offense and corrects an under-indented first argument - accepts a correctly indented first argument - when using safe navigation operator - registers an offense and corrects an under-indented 1st argument - for method calls within method calls - without outer parentheses - accepts a first argument with consistent style indentation - with outer parentheses - accepts a correctly indented first argument with fullwidth characters - accepts a correctly indented first argument in interpolation - registers an offense and corrects an over-indented first argument - registers an offense and corrects an under-indented first argument - when indentation width is overridden for this cop only - registers an offense and corrects an over-indented first argument - accepts a correctly indented first argument - when IndentationWidth:Width is 4 - registers an offense and corrects an over-indented first argument - when EnforcedStyle is consistent_relative_to_receiver - when IndentationWidth:Width is 4 - registers an offense and corrects an over-indented first argument - for method calls within method calls - with outer parentheses - registers an offense and corrects an over-indented 1st argument - indents all relative to the receiver - without outer parentheses - accepts a first argument with special indentation - indents all relative to the receiver - when indentation width is overridden for this cop only - registers an offense and corrects an over-indented first argument - accepts a correctly indented first argument - when IndentationWidth:Width is 2 - registers an offense and corrects lines affected by other offenses - does not view chained call as an outer method call - does not register an offense when argument has expected indent width and the method is preceded by double splat - accepts a first argument that is not preceded by a line break - accepts operator calls - does not register an offense when argument has expected indent width and the method is preceded by splat - registers an offense and corrects an under-indented first argument - accepts method calls with no arguments - does not view []= as an outer method call - registers an offense and corrects an over-indented first argument - when the receiver contains a line break - registers an offense and corrects an over-indented 1st argument - accepts a correctly indented first argument preceded by an empty line - accepts a correctly indented first argument - when preceded by a comment line - accepts a correctly indented first argument - registers an offense and corrects an under-indented first argument - for assignment - register an offense and corrects a correctly indented first argument and does not care about the second argument - with line break - registers an offense and corrects an under-indented first argument - accepts a correctly indented first argument - when EnforcedStyle is special_for_inner_method_call - for method calls within method calls - with outer parentheses - registers an offense and corrects an over-indented first argument - without outer parentheses - accepts a first argument with special indentation - when IndentationWidth:Width is 4 - registers an offense and corrects an over-indented first argument - when IndentationWidth:Width is 2 - registers an offense and corrects an over-indented first argument - registers an offense and corrects an over-indented first argument of `super` - registers an offense and corrects an over-indented first argument on a pipe method name - accepts method calls with no arguments - registers an offense and corrects an over-indented first argument on an alphanumeric method name - registers an offense and corrects lines affected by another offense - does not view []= as an outer method call - accepts a first argument that is not preceded by a line break - accepts operator calls - registers an offense and corrects an over-indented first argument on a plus sign method name - registers an offense and corrects an under-indented first argument - does not view chained call as an outer method call - for a setter call - accepts an unindented value - when the receiver contains a line break - registers an offense and corrects an over-indented first argument - accepts a correctly indented first argument preceded by an empty line - accepts a correctly indented first argument - when preceded by a comment line - registers an offense and corrects an under-indented first argument - accepts a correctly indented first argument - for assignment - accepts a correctly indented first argument and does not care about the second argument - with line break - accepts a correctly indented first argument - registers an offense and corrects an under-indented first argument - when using safe navigation operator - registers an offense and corrects an under-indented 1st argument - when indentation width is overridden for this cop only - accepts a correctly indented first argument - registers an offense and corrects an over-indented first argument +RuboCop::Server::CLI + when not using any server options and specifying `--server` in .rubocop file + returns exit status 0 and display an information message + when not using any server options and specifying `--server` in `RUBOCOP_OPTS` environment variable + returns exit status 0 and display an information message + when using exclusive `--start-server` option + returns exit status 2 and display an error message + when using `--stop-server` option + returns exit status 0 and display a warning message + when using exclusive `--stop-server` option + returns exit status 2 and display an error message + when using `--restart-server` option + returns exit status 0 and display an information and a warning messages + when using `--no-server` option + returns exit status 0 + when using exclusive `--server-status` option + returns exit status 2 and display an error message + when using multiple server options + returns exit status 2 and display an error message + when using `--server` option + returns exit status 0 and display an information message + when using exclusive `--restart-server` option + returns exit status 2 and display an error message + when using server option with `--cache-root=path` option + returns exit status 0 and display an information message + when not using any server options + returns exit status 0 + when using `--server-status` option + returns exit status 0 and display an information message + when using server option with `--cache-root path` option + returns exit status 0 and display an error message + when using `--start-server` option + returns exit status 0 and display an information message -RuboCop::Cop::Layout::SpaceInLambdaLiteral - when configured to enforce no space - registers an offense and corrects a space in the outer nested lambda - does not register an offense for a space between -> and { - registers an offense and corrects a space between -> and ( - registers an offense and corrects a space in the inner nested lambda - does not register an offense for multi-line lambdas - registers an offense and corrects spaces between -> and ( - register offenses and correct spaces in both lambdas when nested - does not register an offense for no space between -> and ( - when configured to enforce spaces - does not register an offense for no space between -> and { - does not register an offense for a space between -> and ( - registers an offense and corrects no space between -> and ( - registers an offense and corrects no space in the inner nested lambda - does not register an offense for multi-line lambdas - registers an offense and corrects no space in both lambdas when nested - registers an offense and corrects no space in the outer nested lambda +RuboCop::Cop::Style::MultilineBlockChain + accepts a chain of blocks spanning one line + accepts a chain of calls followed by a multi-line block + accepts a multi-line block chained with calls on one line + with multi-line block chaining + accepts a chain where the first block is single-line + registers an offense for a chain where the second block is single-line + registers an offense for a simple case + registers an offense for a slightly more complicated case + registers two offenses for a chain of three blocks + Ruby 2.7 + registers an offense for a slightly more complicated case -RuboCop::Cop::Style::RedundantInitialize - does not register an offense for an `initialize` method that calls `super` with a different argument list - does not register an offense for an empty `initialize` method with a argument forwarding` - registers and corrects an offense for an `initialize` method that only calls `super` - registers and corrects an offense for an `initialize` method with arguments that only calls `super` with explicit args - does not register an offense for an empty `initialize` method with a splat` and super - does not register an offense for an empty `initialize` method with a splat` - registers and corrects an offense for an empty `initialize` method - does not register an offense for a method not named `initialize` that only calls super - does not register an offense for an `initialize` method with a default argument that calls `super` - does not register an offense for an `initialize` method with only a comment - registers and corrects an offense for an `initialize` method with arguments that only calls `super` - registers an offense for an `initialize` method with a default argument that does nothing - registers and corrects an offense for an `initialize` method with no arguments that calls `super` with no arguments - does not register an offense for an `initialize` method that calls another method before `super` - does not register an offense for an `initialize` method with a default keyword argument that calls `super` - does not register an offense for an empty `initialize` method with a kwsplat` - registers an offense for an `initialize` method with a default keyword argument that does nothing - does not register an offense for an empty method not named `initialize` - does not register an offense for an `initialize` method that calls another method after `super` - does not register an offense for an `initialize` method that calls another method - does not register an offense for an `initialize` method that calls `super` with no arguments - when `AllowComments: false` - registers and corrects an offense for an `initialize` method with only a comment +RuboCop::Cop::Lint::EmptyFile + registers an offense when the file is empty + does not register an offense when the file contains code + does not register an offense when the file contains comments + when AllowComments is false + registers an offense when the file contains comments -RuboCop::Cop::Severity - overrides #to_s - has a few required attributes - redefines == to compare severities - is frozen - constructs from code - I - is expected to eq # - W - is expected to eq # - F - is expected to eq # - R - is expected to eq # - C - is expected to eq # - E - is expected to eq # - #level - refactor - is expected to eq 2 - warning - is expected to eq 4 - info - is expected to eq 1 - fatal - is expected to eq 6 - convention - is expected to eq 3 - error - is expected to eq 5 - Comparable - refactor - is expected to be < convention - info - is expected to be < refactor - warning - is expected to be < error - convention - is expected to be < warning - error - is expected to be < fatal - #code - convention - is expected to eq "C" - refactor - is expected to eq "R" - info - is expected to eq "I" - warning - is expected to eq "W" - error - is expected to eq "E" - fatal - is expected to eq "F" +RuboCop::Cop::Style::RedundantCondition + when inverted condition (unless) + registers no offense + when condition and else branch are same + registers an offense + accepts complex unless branches + ternary expression (?:) + accepts expressions when the condition and if branch do not match + when condition and if_branch are same + registers an offense and corrects functions + registers an offense and corrects nested vars + registers an offense and corrects with ternary expression and the branches contains parenthesized method call + registers an offense and corrects when the else branch contains `rescue` + registers an offense and corrects when the else branch contains an irange + registers an offense and corrects when the else branch contains an erange + registers an offense and corrects with ternary expression and the branches contains chained parenthesized method call + registers an offense and corrects + registers an offense and corrects when the else branch contains `and` + registers an offense and corrects brackets accesses + registers an offense and corrects class vars + when regular condition (if) + accepts different when the condition does not match the branch + accepts elsif + when condition and if_branch are same + accepts an elsif branch + autocorrects when using `<<` method higher precedence than `||` operator + registers an offense and corrects when defined inside method and the branches contains assignment + registers an offense and corrects multiline nodes + registers an offense and corrects when a method without argument parentheses in `else` + registers an offense and corrects when using modifier if + does not register offenses when the branches contains hash key access + registers an offense and corrects when the branches contains parenthesized method call + does not register an offense when the branches are the same with different receivers + registers an offense and correct when the branches are the same with the same receivers + registers an offense and corrects complex one liners + registers an offense and corrects modifier nodes offense + registers an offense and corrects when `if` condition and `then` branch are the same and it has no `else` branch + registers an offense and corrects + accepts complex else branches + registers an offense and corrects when the branches contains assignment + registers an offense and corrects when the branches contains assignment method + does not register offenses when the branches contains assignment but target not matched + registers an offense and corrects when `raise` without argument parentheses in `else` + does not register an offense when using assignment by hash key access + does not register offenses when using `nil?` and the branches contains assignment + does not register offenses when using `nil?` and the branches contains method which has multiple arguments + registers an offense and corrects when the branches contains method call with non-braced hash + registers an offense and corrects when using operator method in `else` + registers an offense and corrects when the branches contains arithmetic operation + registers an offense and corrects when the else branch contains an irange + registers an offense and corrects when the branches contains method call with braced hash + registers an offense and corrects when the branches contains method call + accepts when using ternary if in `else` branch RuboCop::Formatter::JSONFormatter + #started + sets target file count in summary + #finished + outputs #output_hash as JSON + sets inspected file count in summary #hash_for_file sets an array of #hash_for_offense values for :offenses key sets relative file path for :path key #hash_for_offense - sets Offense#severity value for :severity key - sets Offense#message value for :message key - sets Offense#corrected? value for :corrected key sets Offense#correctable? value for :correctable key - sets Offense#cop_name value for :cop_name key sets value of #hash_for_location for :location key - #finished - outputs #output_hash as JSON - sets inspected file count in summary - #started - sets target file count in summary + sets Offense#message value for :message key + sets Offense#cop_name value for :cop_name key + sets Offense#severity value for :severity key + sets Offense#corrected? value for :corrected key #file_finished adds detected offense count in summary adds value of #hash_for_file to #output_hash[:files] #hash_for_location - sets line value for :line key sets length value for :length key sets column value for :column key + sets line value for :line key when the location is pseudo returns a valid hash -RuboCop::Cop::Bundler::GemFilename - with EnforcedStyle set to `gems.rb` - with non-root gems.locked file path - does not register an offense - with gems.rb file path - does not register an offense - with non-root Gemfile file path +RuboCop::Cop::VariableForce::Reference + .new + when non variable reference node is passed + raises error + +RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets + does not register offense for any kind of reference brackets + when EnforcedStyle is no_space + accepts space inside array brackets if with comment + registers an offense and corrects multiline array on end bracket + does not register offense for valid multiline array + registers an offense and corrects an array literal as an argument with trailing whitespace after a heredoc is started + registers an offense and corrects 2 arrays on one line + does not register offense for arrays with no spaces + does not register offense for arrays using ref brackets + accepts square brackets called with method call syntax + does not register offense when bottom bracket gets its own line indented with tabs + does not register offense when 2 arrays on one line + does not register offense when bottom bracket gets its own line & has trailing method + does not register offense for indented array when bottom bracket gets its own line & is misaligned + registers an offense and corrects an array when two on one line + registers an offense and corrects array brackets with leading whitespace + does not register offense when contains an array literal as an argument after a heredoc is started + accepts square brackets as method name + registers an offense and corrects multiline array on end bracket with trailing method + registers an offense and corrects array brackets with trailing whitespace + does not register offense for array when brackets get own line + accepts a multiline array with whitespace before end bracket + does not register offense for valid 2-dimensional array + when EnforcedStyle is space + does not register offense for valid 2-dimensional array + behaves like space inside arrays + registers an offense and corrects multiline array on end bracket + does not register offense for arrays with spaces + does not register offense for array when brackets get their own line + does not register offense when 2 arrays on one line + registers an offense and corrects multiline array on end bracket with trailing method + does not register offense when bottom bracket gets its own line & has trailing method + accepts space inside array brackets with comment + register an offense and corrects when 2 arrays are on one line + does not register offense for arrays using ref brackets + registers an offense and corrects an array missing whitespace when there is more than one array on a line + registers an offense and corrects array brackets with no leading whitespace + accepts square brackets called with method call syntax + accepts square brackets as method name + does not register offense for indented array when bottom bracket gets its own line & is misaligned + does not register offense for valid multiline array + registers an offense and corrects array brackets with no trailing whitespace + with space inside empty brackets not allowed + accepts empty brackets with no space inside + registers an offense and corrects empty brackets with multiple spaces inside + registers an offense and corrects multiline spaces + registers an offense and corrects empty brackets with 1 space inside + with space inside empty braces allowed + registers an offense and corrects empty brackets with no space inside + accepts empty brackets with space inside + registers an offense and corrects empty brackets with more than one space inside + when EnforcedStyle is compact + registers an offense and corrects space between 2 closing brackets + does not register offense for valid 3-dimensional array + does not register offense for valid 2-dimensional array + accepts multiline array + registers an offense and corrects 2-dimensional array with extra spaces + does not register offense for valid 4-dimensional array + registers an offense and corrects 3-dimensional array with extra spaces + registers an offense and corrects space between 2 opening brackets + behaves like space inside arrays + registers an offense and corrects array brackets with no leading whitespace + registers an offense and corrects multiline array on end bracket with trailing method + does not register offense for indented array when bottom bracket gets its own line & is misaligned + registers an offense and corrects multiline array on end bracket + does not register offense for arrays with spaces + accepts square brackets called with method call syntax + does not register offense when bottom bracket gets its own line & has trailing method + does not register offense when 2 arrays on one line + registers an offense and corrects an array missing whitespace when there is more than one array on a line + accepts square brackets as method name + does not register offense for valid multiline array + does not register offense for array when brackets get their own line + does not register offense for arrays using ref brackets + register an offense and corrects when 2 arrays are on one line + accepts space inside array brackets with comment + registers an offense and corrects array brackets with no trailing whitespace + multiline, 2-dimensional array with newlines + registers an offense and corrects at the end of array + registers an offense and corrects at the beginning of array + multiline, 2-dimensional array with spaces + registers an offense and corrects at the beginning of array + registers an offense and corrects at the end of array + +RuboCop::Cop::Layout::BlockAlignment + accepts end aligned with a method call + accepts end aligned with an instance variable + registers an offense for mismatched block end with a constant + registers an offense for mismatched block end with an and-asgn (&&=) + registers an offense for mismatched block end with an instance variable + accepts end aligned with the block when the block is a method argument + registers an offense for mismatched block end with a class variable + registers an offense for mismatched block end with a variable + accepts end aligned with a method call with arguments + accepts end aligned with a mass assignment + registers an offense for mismatched end with a method call with arguments + accepts end aligned with a call chain left hand side + accepts end aligned with a variable + accepts end aligned with a class variable + accepts end aligned with an and-asgn (&&=) + accepts end aligned with an op-asgn (+=, -=) + accepts end aligned with a constant + does not raise an error for nested block in a method call + registers an offense for mismatched block end with a global variable + accepts a block end that does not begin its line + registers an offense for mismatched end not aligned with the block that is an argument + registers an offense for mismatched block end with a method call + registers an offense for mismatched block end with a mass assignment + registers an offense for mismatched block end with an or-asgn (||=) + accepts end aligned with an or-asgn (||=) + accepts end aligned with a global variable + registers an offense for mismatched block end with an op-asgn (+=, -=) + when the block is a logical operand + accepts a correctly aligned block end + and the block is an operand + accepts end aligned with a variable + on a bit-flipped method call + registers an offense and corrects misaligned end brace + aligns end with the ~ operator + when the block is terminated by } + mentions } (not end) in the message + when the method part is a call chain that spans several lines + accepts end indented as the start of the block + registers offenses for misaligned ends + accepts pretty alignment style + accepts two kinds of end alignment + when variables of a mass assignment spans several lines + accepts end aligned with the variables + registers an offense for end aligned with the block + on a logically negated method call + aligns end with the ! operator + registers an offense and corrects + when the block has arguments + registers an offense for mismatched block end + when there is an assignment chain + accepts end aligned with the first variable + registers an offense for an end aligned with the 2nd variable + on a splatted method call + aligns end with the splat operator + registers an offense and corrects misaligned end braces + when multiple similar-looking blocks have misaligned ends + registers an offense for each of them + on an arithmetically negated method call + aligns end with the - operator + registers an offense and corrects + when the block is defined on the next line + accepts end aligned with the block expression + registers an offenses for mismatched end alignment + when configured to align with start_of_line + allows when start_of_line aligned + errors when do aligned + when configured to align with do + errors when start_of_line aligned + allows when do aligned + when the block has no arguments + registers an offense for mismatched block end + Ruby 2.7 + registers an offense for mismatched block end with a mass assignment + accepts end aligned with a call chain left hand side + +RuboCop::Cop::Lint::NestedMethodDefinition + does not register offense for nested definition inside ::Class.new + does not register offense for nested definition inside Class.new + registers an offense for a nested method definition + does not register offense for nested definition inside class shovel + does not register offense for nested definition inside instance_exec + registers an offense for a nested singleton method definition + registers an offense for a nested method definition inside lambda + does not register offense for nested definition inside instance_eval + does not register offense for nested definition inside class_exec + does not register offense for nested definition inside Module.new + registers an offense for a nested class method definition + does not register an offense for a lambda definition inside method + does not register offense for nested definition inside ::Struct.new + does not register offense for definition of method on local var + does not register offense for nested definition inside ::Module.new + does not register offense for nested definition inside module_exec + does not register offense for nested definition inside module_eval + does not register offense for nested definition inside class_eval + does not register offense for nested definition inside Struct.new + when `AllowedPatterns: [baz]` + registers offense for nested definition inside `do_qux` + does not register offense for nested definition inside `do_baz` + when `AllowedMethods: [has_many]` + registers offense for nested definition inside `denied_method` + does not register offense for nested definition inside `has_many` + +RuboCop::RakeTask + running tasks + exits when result is not 0 and fail_on_error is true + runs with default options + will not error when result is not 0 and fail_on_error is false + runs with specified options if a block is given + allows nested arrays inside formatters, options, and requires + uses the default formatter from .rubocop.yml if no formatter option is given + autocorrect + runs with --autocorrect + runs with --autocorrect-all + runs with with the options that were passed to its parent task + defining tasks + creates a rubocop task and a rubocop autocorrect task + creates a rubocop task and a rubocop auto_correct task + creates a named task and a named auto_correct task + creates a named task and a named autocorrect task + +RuboCop::Cop::Style::RedundantCapitalW + registers an offense for misused %W + registers no offense for %w without interpolation + registers an offense for misused %W with different bracket + registers no offense for normal arrays of strings + does not register an offense for array with one element + registers no offense for %W with special characters + registers no offense for normal arrays of strings with interpolation + registers no offense for arrays with character constants + does not register an offense for array of non-words + registers no offense for %w with interpolation-like syntax + registers no offense for %W with interpolation + does not register an offense for array containing non-string + does not register an offense for array with empty strings + +RuboCop::Cop::Layout::SpaceAfterNot + registers an offense and corrects space after ! with the negated receiver wrapped in parentheses + registers an offense and corrects multiple spaces after ! + accepts space after not keyword + accepts no space after ! + registers an offense and corrects a single space after ! + +RuboCop::Cop::Style::RegexpLiteral + when PercentLiteralDelimiters is configured with brackets + respects the configuration when autocorrecting + when regex contains slashes in interpolation + ignores the slashes that do not belong // regex + when `EnforcedStyle: omit_parentheses` of `Style/MethodCallWithArgsParentheses` cop + when using `%r` regexp with `EnforcedStyle: mixed` + does not register an offense when used as a safe navigation method argument + does not register an offense when used as a method argument + registers an offense when not used as a method argument + when using `%r` regexp with `EnforcedStyle: slashes` + does not register an offense when used as a method argument + does not register an offense when used as a safe navigation method argument + registers an offense when not used as a method argument + when `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` cop + when using `%r` regexp with `EnforcedStyle: slashes` + registers an offense when used as a method argument + registers an offense when not used as a method argument + does not register an offense when using a regexp starts with a blank as a method argument + registers an offense when using a regexp starts with a blank + does not register an offense when using a regexp starts with a blank as a safe navigation method argument + registers an offense when used as a safe navigation method argument + when using `%r` regexp with `EnforcedStyle: mixed` + registers an offense when not used as a method argument + does not register an offense when using a regexp starts with a blank as a safe navigation method argument + registers an offense when using a regexp starts with a blank + registers an offense when used as a method argument + registers an offense when used as a safe navigation method argument + does not register an offense when using a regexp starts with a blank as a method argument + when PercentLiteralDelimiters is configured with slashes + respects the configuration when autocorrecting + when EnforcedStyle is set to mixed + a multi-line %r regex with slashes + is accepted + a single-line %r regex with slashes + is accepted + when configured to allow inner slashes + registers an offense + a single-line `//` regex without slashes + is accepted + a multi-line `//` regex without slashes registers an offense - with non-root gems.rb file path - does not register an offense - with non-root Gemfile.lock file path + a single-line %r regex without slashes registers an offense - with Gemfile.lock file path + a multi-line `//` regex with slashes registers an offense - with Gemfile file path + a single-line `//` regex with slashes registers an offense - with default configuration (EnforcedStyle => `Gemfile`) - with non-root gems.rb file path + when configured to allow inner slashes + is accepted + a multi-line %r regex without slashes + is accepted + when EnforcedStyle is set to percent_r + a single-line `//` regex with slashes registers an offense - with gems.rb file path + a single-line %r regex without slashes + is accepted + a multi-line %r regex with slashes + is accepted + a single-line %r regex with slashes + is accepted + a multi-line %r regex without slashes + is accepted + a multi-line `//` regex with slashes registers an offense - with gems.locked file path + a multi-line `//` regex without slashes registers an offense - with Gemfile.lock file path + a single-line `//` regex without slashes + registers an offense + when EnforcedStyle is set to slashes + a multi-line %r regex with slashes + is accepted + when configured to allow inner slashes + registers an offense + a single-line `//` regex without slashes + is accepted + a single-line %r regex with slashes + is accepted + when configured to allow inner slashes + registers an offense + a multi-line `//` regex with slashes + registers an offense + when configured to allow inner slashes + is accepted + a multi-line %r regex without slashes + registers an offense + a multi-line `//` regex without slashes + is accepted + a single-line `%r//` regex with slashes + is accepted + when configured to allow inner slashes + preserves slashes after autocorrection + a single-line `//` regex with slashes + registers an offense + when configured to allow inner slashes + is accepted + a single-line %r regex without slashes + registers an offense + a single-line `//` regex with slashes and interpolation + registers an offense + when configured to allow inner slashes + is accepted + %r regex with other delimiters than curly braces + registers an offense + +RuboCop::Cop::Style::EachForSimpleLoop + does not register offense for character range + does not register offense if range startpoint is not constant + does not register offense if range endpoint is not constant + when using an exclusive end range + autocorrects the source with multiline block + autocorrects the range not starting with zero + autocorrects the source with inline block + does not register offense for range not starting with zero and using param + with multiline block with parameters + autocorrects an offense + with inline block with parameters + autocorrects an offense + when using an inclusive end range + autocorrects the source with multiline block + does not register offense for range not starting with zero and using param + autocorrects the source with inline block + autocorrects the range not starting with zero + +Changelog + merges correctly + parses correctly + Changelog::Entry + #content + when there is no issue referenced + generates correct content + when there is an issue referenced + generates correct content + #ref_id + when there is no body + is expected to eq "x" + when there is an issue referenced with [Fixes #x] the body + is expected to eq "123" + when there is no issue referenced in the body + is expected to eq "x" + when there is an issue referenced with [Fix #x] the body + is expected to eq "123" + #body + when there is no issue referenced in the body + is expected to eq "Fix something" + when there is an issue referenced with [Fix #x] the body + is expected to eq "Fix something" + when there is no body + is expected to eq "" + when there is an issue referenced with [Fixes #x] the body + is expected to eq "Fix something" + +RuboCop::Cop::Lint::CircularArgumentReference + circular argument references in ordinal arguments + when the method does not contain a circular argument reference does not register an offense - with non-root Gemfile.lock file path + when the method contains a circular argument reference + registers an offense + when the seemingly-circular default value is a method call does not register an offense - with non-root Gemfile file path + circular argument references in keyword arguments + when the keyword argument is not circular, but calls a method of some other object with the same name does not register an offense - with Gemfile file path + when the keyword argument is not circular, but calls a method of its own class with a self specification does not register an offense - with non-root gems.locked file path + when the keyword argument is not circular + does not register an offense + when there is one circular argument reference registers an offense - -RuboCop::Cop::Style::SwapValues - does not register an offense when almost swapping variables - handles comments when correcting - does not register an offense when assigning receiver object at `def` - does not register an offense when idiomatically swapping variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping class variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping local variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping mixed variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping instance variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping global variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping constant variables - behaves like verbosely swapping - registers an offense and corrects when verbosely swapping constant with namespaces variables - -RuboCop::Cop::Lint::RegexpAsCondition - does not register an offense for a regexp literal with `=~` operator - does not register an offense for a regexp literal outside conditions - registers an offense and corrects for a regexp literal in `if` condition - -RuboCop::Cop::InternalAffairs::RedundantLocationArgument - when location argument is passed - when location argument is :expression - removes default `location` surrounded by other keywords + when there are multiple offensive keyword arguments registers an offense - removes default `location` when preceded by another keyword - when there is a message argument - registers an offense - when location argument does not equal to :expression + when the keyword argument is not circular, and calls a method does not register an offense - when location argument is not passed - does not register an offense - -RuboCop::Cop::InternalAffairs::ExampleHeredocDelimiter - when unexpected heredoc delimiter is used in multi-line heredoc - registers an offense - when unexpected heredoc delimiter is used in single-line heredoc - registers an offense - when expected heredoc delimiter is used at RuboCop specific expectation - does not register an offense - when unexpected heredoc delimiter is used but heredoc body contains an expected delimiter line - does not register an offense - when unexpected heredoc delimiter is used at non RuboCop specific expectation - does not register an offense -RuboCop::Cop::Style::AccessorGrouping - when EnforcedStyle is separated - registers an offense and corrects when using grouped accessors within eigenclass - does not register an offense if the same accessor is listed twice - registers an offense and corrects when the same accessor is given more than once in the same statement - does not register an offense when using separated accessors - registers an offense and corrects when using grouped accessors with different access modifiers - does not register an offense for grouped accessors with comments - registers an offense and corrects when using grouped accessors - when there are comments for attributes - registers and corrects an offense - when EnforcedStyle is grouped - does not register an offense when the same accessor is given more than once in the same statement - registers an offense and corrects when using separated accessors within eigenclass - registers an offense and corrects when using separated accessors - does not register an offense when using grouped accessors - registers an offense and corrects when using separated accessors with different access modifiers - does not register offense for accessors with comments - registers offense and corrects if at least two separate accessors without comments - registers an offense and correct if the same accessor is listed twice +RuboCop::Cop::Lint::DuplicateRescueException + registers an offense when duplicate exception splat exists + registers an offense when duplicate exception exists within rescues with empty `rescue` branch + does not register an offense when there are no duplicate exceptions + registers an offense when multiple duplicate exceptions exist + registers an offense when duplicate exception exists within rescues with `else` branch + registers an offense when duplicate exception exists -RuboCop::Cop::Style::Encoding - does not register an offense when encoding is not at the top of the file - does not register an offense when encoding is in the wrong place - registers an offense and corrects if there are multiple encoding magic comments - does not register an offense on a different magic comment type - does not register an offense when encoding present but not UTF-8 - does not register an offense when no encoding present - registers an offense and corrects the magic comment follows another magic comment - registers an offense when encoding present and UTF-8 - registers an offense when encoding present on 2nd line after shebang - emacs comment - registers an offense for encoding - only removes encoding if there are other editor comments - vim comments - registers an offense and corrects +RuboCop::Cop::Style::WhileUntilDo + accepts multi-line while without do + accepts do in single-line until + registers an offense for do in multiline while + accepts do in single-line while + accepts multi-line until without do + registers an offense for do in multiline until -RuboCop::Cop::Style::Copyright - does not register an offense when the notice is not the first comment - does not register an offense when the notice is in a block comment - does not register an offense when the notice is present - when the source code file is empty - adds an offense - when the copyright notice is missing - fails to autocorrect when the AutocorrectNotice does not match the Notice pattern - adds an offense - fails to autocorrect if no AutocorrectNotice is given - when the copyright notice is missing and the source code file starts with a shebang - adds an offense - when the copyright notice comes after any code - adds an offense - when the copyright notice is missing and the source code file starts with shebang and an encoding comment - adds an offense - when the copyright notice is missing and the source code file starts with an encoding comment - adds an offense +RuboCop::Cop::Layout::EmptyLinesAroundMethodBody + accepts method body starting with a line with spaces + registers an offense for class method body ending with a blank + registers an offense for method body ending with a blank + registers an offense for method body starting with a blank + is not fooled by single line methods + registers an offense for class method body starting with a blank -RuboCop::Cop::Style::StringConcatenation - does not register an offense when using `+` with all non string arguments - registers an offense and corrects for string concatenation as part of other expression - correctly handles strings with special characters - registers an offense and corrects for string concatenation - correctly handles nested concatenable parts - nested interpolation - registers an offense and corrects - Mode = conservative - when first operand is not string literal - does not register offense - when first operand is string literal - registers offense - double quotes inside string surrounded single quotes - registers an offense and corrects with double quotes - heredoc - registers an offense but does not correct when string concatenation with multiline heredoc text - registers an offense but does not correct - double quotes inside string - registers an offense and corrects with double quotes - registers an offense and corrects with percentage quotes - inline block - registers an offense but does not correct - empty quotes - registers offense and corrects - multiline - simple expressions - registers an offense and corrects - if condition - registers an offense but does not correct - multiline block - registers an offense but does not correct - string continuation - does not register an offense +RuboCop::Cop::Style::MixinGrouping + when configured with grouped style + when using `prepend` + registers an offense when other mixins have receivers + registers an offense for single mixins in separate calls, interspersed + registers an offense for single mixins in separate calls + when using `extend` + registers an offense for single mixins in separate calls + when using a mix of diffent methods + allows all different mixin methods + registers an offense with some duplicated mixin methods + when using include + registers an offense for single mixins in separate calls + registers an offense for several mixins in separate calls + allows include with an explicit receiver + when configured with separated style + when using `include` + allows include call as an argument to another method + registers an offense for several mixins in one call + registers an offense for several mixins in separate calls + when using `extend` + registers an offense for several mixins in one call + when using `prepend` + registers an offense for several mixins in one call + when using a mix of diffent methods + registers an offense for some calls having several mixins -RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler - registers and corrects an offense when using `IO.select` with single read as `self` and timeout arguments - registers an offense when using `IO.select` with read argument and using return value but does not autocorrect - registers and corrects an offense when using `IO.select` with single write argument - does not register an offense when using `IO.select` with read and write arguments - does not register an offense when using `IO.select` with multiple write arguments - registers and corrects an offense when using `IO.select` with single read, `nil`, and timeout arguments - registers and corrects an offense when using `::IO.select` with single read argument - registers and corrects an offense when using `IO.select` with multiple read argument and specify the first argument only - does not register an offense when using `IO.select` with multiple read arguments - registers and corrects an offense when using `IO.select` with single read argument - registers an offense when using `IO.select` with write argument and using return value but does not autocorrect - registers and corrects an offense when using `IO.select` with single write and timeout arguments - registers and corrects an offense when using `::IO.select` with single read and timeout arguments - registers and corrects an offense when using `IO.select` with single write, `nil`, and timeout arguments - registers and corrects an offense when using `IO.select` with single read argument and specify the first argument only - does not register an offense when using `Enumerable#select` - registers and corrects an offense when using `IO.select` with single read and timeout arguments - registers and corrects an offense when using `IO.select` with single write as `self` and timeout arguments - -RuboCop::Cop::Layout::LineEndStringConcatenationIndentation - when EnforcedStyle is aligned - accepts a heredoc string ... - accepts an empty heredoc string with interpolation - registers an offense for aligned strings in an if/elsif/else statement - accepts string literal with line break concatenated with other string - accepts a multiline string literal - accepts indented strings in implicit return statement of a block - accepts indented strings in implicit return statement of a method definition after other statement - accepts aligned strings in method call - accepts a heredoc string with interpolation - accepts single line string literal concatenation - registers an offense for indented string - registers an offense for third part of a string if it is aligned only with the first - accepts indented strings in implicit return statement of a method definition - accepts indented strings in implicit return statement of a singleton method definition - registers an offense for unaligned strings in hash literal values - accepts indented strings in ordinary statement - for assignment with $x = - registers an offense for indented strings - accepts aligned strings - for assignment with X = - accepts aligned strings - registers an offense for indented strings - for assignment with x += - accepts aligned strings - registers an offense for indented strings - for assignment with @x = - registers an offense for indented strings - accepts aligned strings - for assignment with x = - registers an offense for indented strings - accepts aligned strings - for assignment with x ||= - registers an offense for indented strings - accepts aligned strings - when EnforcedStyle is indented - accepts a heredoc string with interpolation - accepts an empty heredoc string with interpolation - accepts single line string literal concatenation - accepts indented strings - accepts string literal with line break concatenated with other string - registers an offense for aligned strings in hash literal values - accepts indented strings in implicit return statement of a method definition - registers an offense for aligned string - accepts indented strings in implicit return statement of a method definition after other statement - registers an offense for aligned strings in an if/elsif/else statement - accepts a heredoc string ... - accepts a multiline string literal - accepts indented strings in implicit return statement of a block - accepts indented strings in ordinary statement - registers an offense for unaligned third part of string - accepts indented strings in implicit return statement of a singleton method definition - for assignment with X = - registers an offense for aligned strings - accepts indented strings - for assignment with x += - registers an offense for aligned strings - accepts indented strings - for assignment with @x = - accepts indented strings - registers an offense for aligned strings - when IndentationWidth is 1 - accepts indented strings - for assignment with $x = - registers an offense for aligned strings - accepts indented strings - for assignment with x = - accepts indented strings - registers an offense for aligned strings - for assignment with x ||= - registers an offense for aligned strings - accepts indented strings - -RuboCop::Cop::Layout::LeadingCommentSpace - does not register an offense for # followed by no text - does not register an offense for only #s - accepts sprockets directives - accepts =begin/=end comments - does not register an offense for more than one # - registers an offense and corrects #! after the first line - registers an offense and corrects comment without leading space - does not register an offense for more than one space - does not register an offense for #! on first line - file not named config.ru - registers an offense and corrects #\ after the first line - registers an offense and corrects #\ on first line - Gemfile Ruby comment - when config option is enabled - file named Gemfile - does not register an offense when using ruby config as comment - file not named Gemfile - registers an offense when using ruby config as comment - when config option is disabled - registers an offense when using ruby config as comment - RDoc syntax - does not register an offense when using `#++` or `#--` - registers an offense when starting `:` - file named config.ru - does not register an offense for #\ on first line - registers an offense and corrects for #\ after the first line - Doxygen style - when config option is enabled - does not register offense when using Doxygen style - when config option is disabled - registers an offense and corrects using Doxygen style +RuboCop::CLI --autocorrect + does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: special_for_inner_method_call` of `Layout/FirstArgumentIndentation` + corrects TrailingCommaIn(Array|Hash)Literal and Multiline(Array|Hash)BraceLayout offenses + corrects `EnforcedStyle: hash_rockets` of `Style/HashSyntax` with `Layout/HashAlignment` + corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `Layout/HashAlignment` and `Layout/FirstHashElementIndentation` + can change block comments and indent them + corrects IndentationWidth, RedundantBegin, and RescueEnsureAlignment offenses + can correct two empty lines at end of class body + can correct two problems with blocks + corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent` of `Layout/FirstArgumentIndentation` + can be disabled for any cop in configuration + corrects SymbolProc and SpaceBeforeBlockBraces offenses + corrects `Style/RedundantBegin` with `Style/MultilineMemoization` + corrects `Style/InverseMethods` offenses when specifying `IncludeSemanticChanges: false` of `Style/NonNilCheck` and `EnforcedStyle: comparison` of `Style/NilComparison` + indents the elements of a hash in hash based on the parent hash key when the parent hash is a method argument and has following other sibling pairs + corrects IndentationWidth and IndentationConsistency offenseswithout correcting `Style/TrailingBodyOnClass` + can correct HashSyntax and SpaceAroundOperators offenses + corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Lint/AmbiguousOperator` + corrects `Layout/SpaceAroundOperators` and `Layout/ExtraSpacing` offenses when using `ForceEqualSignAlignment: true` + corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedHashRocketStyle: separator` of `Layout/HashAlignment` + avoids adding extra spaces when both `Style/Semicolon` and `Style/SingleLineMethods`both apply + can correct indentation and another thing + corrects Lint/ParenthesesAsGroupedExpression and offenses and accepts Style/RedundantParentheses + can correct empty line inside special form of nested modules + does not correct Style/IfUnlessModifier offense disabled by a comment directive and does not fire Lint/RedundantCopDisableDirective offense even though that directive would make the modifier form too long + corrects Style/BlockDelimiters offenses when specifyingLayout/SpaceInsideBlockBraces together + corrects code with indentation problems + corrects Layout/RedundantLineBreak and Layout/SingleLineBlockChain offenses + properly autocorrects when `Style/TernaryParentheses` requires parentheses that `Style/RedundantParentheses` would otherwise remove + plays nicely with default cops in complex ExtraSpacing scenarios + does not crash when using `Layout/CaseIndentation` and `Layout/ElseAlignment` + does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent_relative_to_receiver` of `Layout/FirstArgumentIndentation` + corrects HeredocArgumentClosingParenthesis offenses and ignores TrailingCommaInArguments offense + corrects `Naming/RescuedExceptionsVariableName` and `, `Style/RescueStandardError`and `Lint/OverwriteByRescue` offenses + corrects Style/Next and Style/SafeNavigation offenses + does not crash `Layout/ArgumentAlignment` and offenses and accepts `Layout/FirstArgumentIndentation` when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: special_for_inner_method_call_in_parentheses` of `Layout/FirstArgumentIndentation` + does not correct SpaceAroundOperators in a hash that would be changed back + corrects Style/InverseMethods and Style/Not offenses + can correct a problems and the problem it creates + can correct WordArray and SpaceAfterComma offenses + can correct TrailingEmptyLines and TrailingWhitespace offenses + corrects Tab and IndentationConsistency offenses + does not correct ExtraSpacing in a hash that would be changed back + corrects only IndentationWidth without crashing + can correct MethodCallWithoutArgsParentheses and EmptyLiteral offenses + does not crash when using Lint/SafeNavigationWithEmpty and Layout/EmptyLinesAroundBlockBody + can correct HashSyntax when --only is used + corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedColonStyle: separator` of `Layout/HashAlignment` (`EnforcedColonStyle` is array) + corrects InitialIndentation offenses + corrects indentation for a begin/rescue/else/ensure/end block properly + can correct IndentHash offenses with separator style + honors Exclude settings in individual cops + corrects RedundantBegin offenses and fixes indentation etc + corrects `Layout/DotPosition` and `Layout/SingleLineBlockChain` offenses + does not crash Lint/SafeNavigationWithEmpty and offenses and accepts Style/SafeNavigation when checking `foo&.empty?` in a conditional + can correct single line methods + does not say [Corrected] if correction is not possible + corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Style/RescueModifier` + corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Layout/SpaceBeforeFirstArg` + corrects `Lint/UnusedMethodArgument` with `Style/ExplicitBlockArgument` + says [Correctable] if correction is unsafe + corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `Style/NestedParenthesizedCalls` + does not hang SpaceAfterPunctuation and SpaceInsideParens + corrects `EnforcedStyle: require_parentheses` of `Style/MethodCallWithArgsParentheses` with `EnforcedStyle: conditionals` of `Style/AndOr` + corrects `Style/TernaryParentheses` offenses and accepts `Lint/ParenthesesAsGroupedExpression` + corrects `Style/IfUnlessModifier` with `Style/SoleNestedConditional` + consistently quotes symbol keys in a hash using `Lint/SymbolConversion` with `EnforcedStyle: consistent` and `Style/QuotedSymbols` + corrects IndentationWidth and IndentationConsistency offenses + corrects `Style/SoleNestedConditional` with `Style/InverseMethods` and `Style/IfUnlessModifier` + breaks line at the beginning of trailing class/module body without removing a semicolon in the bodywhen using `Style/TrailingBodyOnClass` and `Style/TrailingBodyOnModule` + corrects IndentationWidth and IndentationConsistency offenseswhen using `EnforcedStyle: outdent` and `EnforcedStyle: indented_internal_methods` + corrects Style/BlockDelimiters offenses when specifyingLayout/SpaceBeforeBlockBraces with `EnforcedStyle: no_space` together + corrects LineEndConcatenation offenses leaving the RedundantInterpolation offense unchanged + handles different SpaceInsideBlockBraces and SpaceInsideHashLiteralBraces + corrects properly when both `Style/MapToHash` and `Style/HashTransformKeys`or `Style/HashTransformValues` registers + properly corrects when `Style/SoleNestedConditional` and one of `Style/NegatedIf` or `Style/NegatedUnless` detect offenses + corrects `Lint/Lambda` and `Lint/UnusedBlockArgument` offenses + registers an offense and corrects when using `Layout/ArgumentAlignment`, `Layout/FirstArgumentIndentation`, and `Layout/FirstMethodArgumentLineBreak` and specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `EnforcedStyle: consistent` of `Layout/FirstArgumentIndentation` + corrects when specifying `EnforcedStyle: with_first_argument` of `Layout/ArgumentAlignment` and `EnforcedColonStyle: separator` of `Layout/HashAlignment` + can correct two problems in the same place + can correct SpaceAfterComma and HashSyntax offenses + can correct MethodDefParentheses and other offense + corrects when specifying `EnforcedStyle: with_fixed_indentation` of `Layout/ArgumentAlignment` and `Layout/HashAlignment` + corrects RedundantCopDisableDirective offenses + does not hang SpaceAfterPunctuation and SpaceInsideArrayLiteralBrackets + corrects `EnforcedStyle: line_count_based` of `Style/BlockDelimiters` with `Style/CommentedKeyword` and `Layout/BlockEndNewline` + corrects `Layout/DotPosition` and `Style/RedundantSelf` offenses + when BlockDelimiters has semantic style + corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses + caching + with no offenses in the cache + doesn't correct offenses + with an offense in the cache + corrects offenses + space_inside_bracket cops + when array style is space & reference style is no space + corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets + when array style is compact & reference style is no_space + corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets + when array style is no_space & reference style is space + corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets + when array style is compact & reference style is space + corrects SpaceInsideArrayLiteralBrackets and SpaceInsideReferenceBrackets + trailing comma cops + when the style is `comma` + corrects TrailingCommaInLiteral and TrailingCommaInArguments without producing a double comma + when the style is `consistent_comma` + corrects TrailingCommaInLiteral and TrailingCommaInArguments without producing a double comma + when BlockDelimiters has line_count_based style + corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses + when BlockDelimiters has braces_for_chaining style + corrects SpaceBeforeBlockBraces, SpaceInsideBlockBraces offenses -RuboCop::Cop::Layout::MultilineHashBraceLayout - ignores single-line hashes - ignores empty hashes - ignores implicit hashes - behaves like multiline literal brace layout method argument - when arguments to a method - but no comment after the last element - autocorrects the closing brace - and a comment after the last element - detects closing brace on separate line from last element - behaves like multiline literal brace layout - heredoc - detects heredoc structures that are safe to add to - ignores heredocs that could share a last line - symmetrical style - opening brace on separate line from first element - allows closing brace on separate line from last element - allows closing brace on separate line from last multiline element - detects closing brace on same line as last element - opening brace on same line as first element - autocorrects closing brace on different line from last element - detects closing brace on different line from last element - allows closing brace on same line as last multiline element - allows closing brace on same line as last element - with a chained call on the closing brace - but no comment after the last element - autocorrects the closing brace - and a comment after the last element - detects closing brace on separate line from last elementbut does not autocorrect the closing brace - same_line style - opening brace on separate line from first element - allows closing brace on same line as last multiline element - detects closing brace on different line from last element - allows closing brace on same line as last element - opening brace on same line as first element - allows closing brace on same line as multi-line element - detects closing brace on different line from multiline element - autocorrects closing brace on different line as last element - allows closing brace on same line from last element - with a chained call on the closing brace - and a comment after the last element - detects closing brace on separate line from last elementbut does not autocorrect the closing brace - but no comment after the last element - autocorrects the closing brace - new_line style - opening brace on same line as first element - allows closing brace on different line from multi-line element - detects closing brace on same line as last multiline element - autocorrects closing brace on same line as last element - allows closing brace on different line from last element - opening brace on separate line from first element - allows closing brace on separate line from last element - detects closing brace on same line as last element - allows closing brace on separate line from last multiline element - behaves like multiline literal brace layout trailing comma - same_line style - opening brace on same line as first element - last element has a trailing comma - autocorrects closing brace on different line as last element - symmetrical style - opening brace on same line as first element - last element has a trailing comma - autocorrects closing brace on different line from last element +RuboCop::Cop::Style::EmptyMethod + when configured with expanded style + with a non-empty instance method definition + allows multi line method + allows multi line method with a comment + allows single line method + with an empty instance method definition + allows multi line method + allows multi line method with blank line + registers an offense for single line method + relation with Layout/LineLength + still corrects even if the method is longer than the configured Max + with an empty class method definition + allows empty multi line method + registers an offense for single line method + allows multi line method with a blank line + with a non-empty class method definition + allows single line method + allows multi line method + allows multi line method with comment + when method is nested in class scope + registers an offense for single line method + when configured with compact style + with an empty instance method definition + registers an offense for method with arguments + allows single line method + registers an offense for method with closing paren on following line + registers an offense for empty method + registers an offense for method with arguments without parens + registers an offense for method with blank line + with an empty class method definition + registers an offense for empty method + registers an offense for empty method with arguments + allows single line method + registers an offense for method with blank line + relation with Layout/LineLength + when that cop is disabled + corrects to long lines + when the correction would exceed the configured maximum + reports an offense but does not correct + with a non-empty class method definition + allows multi line method + allows multi line method with comment + allows single line method + with a non-empty instance method definition + allows single line method + allows multi line method with comment + allows multi line method -RuboCop::Cop::Lint::RescueException - registers an offense for rescue with ::Exception - does not register an offense for rescue with no class and => e - does not crash when the splat operator is used in a rescue - does not register an offense for rescue with other class - does not crash when the namespace of a rescued class is in a local variable - does not register an offense for rescue with no class - does not register an offense for rescue with other classes - registers an offense for rescue with StandardError, Exception - does not register an offense for rescue with a module prefix - registers an offense for rescue from Exception - registers an offense for rescue with Exception => e +RuboCop::Cop::Style::CharacterLiteral + autocorrects ?' to "'" + accepts ? in a %w literal + accepts literals like ?\C-\M-d + registers an offense for literals like \n + registers an offense for character literals -RuboCop::Cop::Style::LineEndConcatenation - accepts string concat at line end when % literals are involved - autocorrects a + with trailing whitespace to \ - accepts string concat on the same line - registers an offense for string concat with << at line end - accepts string concat at line end for special strings like __FILE__ - registers multiple offenses when there are chained concatenations - registers an offense for dynamic string concat at line end - registers an offense for string concat with << and \ at line ends - accepts string concat with a return value of method on an interpolated string - autocorrects a + with \ to just \ - registers multiple offenses when there are chained concatenationscombined with << calls - registers offenses only for the appropriate lines in chained concats - accepts string concat at line end when followed by comment - registers multiple offenses when there are chained << methods - registers an offense for dynamic string concat with << at line end - accepts string concat at line end when followed by a comment line - autocorrects only the lines that should be autocorrected - accepts string concat with a return value of method on a string - registers an offense for string concat at line end +RuboCop::Cop::Lint::FlipFlop + registers an offense for exclusive flip-flops + registers an offense for inclusive flip-flops -RuboCop::Cop::Layout::ElseAlignment - accepts a ternary if - ensure/rescue/else in Block Argument - accepts a correctly aligned else with assignment - accepts a correctly aligned else - registers an offense for misaligned else - with def/rescue/else/end - accepts a correctly aligned else - registers an offense for misaligned else - with def/rescue/else/ensure/end - registers an offense for misaligned else - accepts a correctly aligned else - with if statement - accepts indentation after else when if is on new line after assignment - registers an offense for misaligned elsif - accepts an if/else branches with rescue clauses - registers an offense for misaligned else - accepts a one line if statement - accepts a correctly aligned if/elsif/else/end - for a file with byte order mark - accepts a correctly aligned if/elsif/else/end - with assignment - when alignment style is variable - and end is aligned with variable - accepts an if/else with chaining with a block after the end - accepts an if/else with chaining after the end - accepts an if with end aligned with element assignment - accepts an if-else with end aligned with setter - accepts an if/else - accepts an if-elsif-else with end aligned with setter - and end is aligned with keyword - registers offenses for an if with setter - registers an offense for an if - registers an offense for an if with element assignment - when alignment style is keyword by choice - and end is aligned with variable - registers an offense for an if - and end is aligned with keyword - accepts a while in assignment - accepts an if/else in assignment on next line - accepts an if/else in assignment - accepts an if in assignment - accepts an until in assignment - with begin/rescue/else/ensure/end - accepts a correctly aligned else - registers an offense for misaligned else - with unless - accepts an empty unless - accepts a correctly aligned else in an otherwise empty unless - registers an offense for misaligned else - with def/defs - accepts an empty defs body - accepts an empty def body - when modifier and def are on the same line - registers an offense for else not aligned with private - accepts a correctly aligned body - with case - accepts case without else - accepts correctly aligned case/when/else - accepts else aligned with when but not with case - registers an offense for misaligned else - >= Ruby 2.7 - with case match - registers an offense for misaligned else - accepts correctly aligned case/when/else - accepts correctly aligned empty else - accepts case match without else +RuboCop::Cop::Style::NegatedWhile + accepts a while where the condition is doubly negated + registers an offense for while with exclamation point condition + registers an offense for while with "not" condition + autocorrects by replacing while not with until + registers an offense for until with exclamation point condition + does not blow up for empty until condition + autocorrects by replacing until not with while + does not blow up for empty while condition + accepts a while where only part of the condition is negated -RuboCop::Cop::Style::TrailingCommaInBlockArgs - when `lambda` has multiple arguments - registers an offense and corrects when a trailing comma isn't needed - does not register an offense when more than one argument is present with no trailing comma - do/end block format - preserves semicolons in block/local variables - does not register an offense when a trailing comma is required - does not register an offense when no arguments are present - does not register an offense for default arguments - registers an offense when a trailing comma is not needed - does not register an offense for keyword arguments - does not register an offense for an empty block - does not register an offense when more than one argument is present with no trailing comma - ignores commas in default argument strings - when `->` has multiple arguments - does not register an offense - curly brace block format - does not register an offense when no arguments are present - ignores commas in default argument strings - registers an offense when a trailing comma is not needed - preserves semicolons in block/local variables - does not register an offense for default arguments - does not register an offense for keyword arguments - does not register an offense when a trailing comma is required - does not register an offense when more than one argument is present with no trailing comma +RuboCop::Cop::Style::IfInsideElse + handles a nested `if...then...elsif...else...end` + catches an `if..else` nested inside an `else` and nested inside `if` branch code is empty + ignores nested ternary expressions + catches an if..elsif..else nested inside an else + handles a nested `if...then...end` + isn't offended by if..elsif..else + handles a nested `if...then...else...end` + handles a nested `if...then...elsif...end` + ignores if inside unless + isn't offended if there is a statement following the if node + ignores ternary inside if..else + catches an if node nested inside an else + catches an if..else nested inside an else + isn't offended if there is a statement preceding the if node + handles a nested multiline `if...then...elsif...else...end` + catches a modifier if nested inside an else after elsif + ignores unless inside else + when AllowIfModifier is false + catches a modifier if nested inside an else + when AllowIfModifier is true + accepts a modifier if nested inside an else -RuboCop::Cop::Style::SoleNestedConditional - registers an offense and corrects when `if` foo do_something end `unless` bar && baz - does not register an offense for nested conditionals when outer conditional has an `else` branch - registers an offense and corrects for multiple nested conditionals with using method call outer condition by omitting parentheses - registers an offense and corrects when using `unless` and method arguments without parentheses in the outer condition and nested modifier condition - registers an offense and corrects when using nested `unless` modifier conditional - registers an offense and corrects when `if` foo do_something end `unless` bar - registers an offense and corrects for multiple nested conditionals - registers an offense and corrects when using nested `unless` within `unless` - registers an offense and corrects when using `unless` and multiple method arguments with parenthesesin the outer condition and nested modifier condition - registers an offense and corrects when using nested `if` within `if foo = bar` - does not register an offense when nested conditional has an `else` branch - registers an offense and corrects when using nested `if` modifier conditional - registers an offense and corrects when `if` foo && bar do_something end `if` baz - registers an offense and corrects when using `unless` and method arguments with parentheses in the outer condition and nested modifier condition - does not register an offense when no nested conditionals - registers an offense and corrects when `if` foo do_something end `if` bar - registers an offense and corrects when nested `||` operator modifier condition - registers an offense and corrects when using nested conditional and branch contains a comment - registers an offense and corrects when using nested `if` within `if` - registers an offense and corrects when using nested `if` within `unless foo == bar` - does not register an offense when using nested ternary within conditional - registers an offense and corrects when using `unless` and `||` and parens in the outer condition and nested modifier condition - registers an offense and corrects when using nested `unless` within `if` - registers an offense and corrects when using `||` in the outer condition and nested modifier condition - registers an offense and corrects when `if` foo && bar do_something end `unless` baz - does not register an offense when using nested conditional within `elsif` - does not register an offense when using nested modifier on value assigned in multiple conditions - registers an offense and corrects when `unless` foo do_something end `if` bar - registers an offense and corrects when using guard conditional with outer comment - registers an offense and corrects when `unless` foo && bar do_something end `if` baz - does not register an offense when using nested modifier on value assigned in single condition - registers an offense and corrects when using nested `unless` modifier with a single expression condition - registers an offense and corrects when using `unless` and `&&` without parens in the outer condition and nested modifier condition - registers an offense and corrects when using `||` in the outer condition - registers an offense and corrects when nested `||` operator condition - registers an offense and corrects when using nested `unless` modifier multiple conditional - registers an offense and corrects when using nested `if` within `unless` - does not register an offense when using nested conditional is not the whole body - registers an offense and corrects when using `unless` and `||` without parens in the outer condition and nested modifier condition - registers an offense and corrects when `if` foo do_something end `if` bar && baz - registers an offense and corrects when there are outer and inline comments - when disabling `Style/IfUnlessModifier` - registers an offense and corrects when using nested conditional and branch contains a comment - registers an offense and corrects when there are outer and inline comments - when AllowModifier is true - does not register an offense when using nested modifier conditional - when the inner condition has a send node without parens - in modifier style - registers an offense and corrects - with a block - registers an offense and corrects - with a `csend` node - registers an offense and corrects - in guard style - registers an offense and corrects - when the inner condition has a send node with parens - in guard style - registers an offense and corrects - in modifier style +RuboCop::Cop::Style::IdenticalConditionalBranches + on case with identical trailing lines + registers and corrects an offense + on if..else with slightly different trailing lines + doesn't register an offense + on case with identical leading lines + registers and corrects an offense + on if..else with identical leading lines + registers and corrects an offense + on case without else + doesn't register an offense + when using pattern matching + on case-match with empty when + doesn't register an offense + on case-match with identical leading lines + registers and corrects an offense + on case-match with identical bodies registers an offense and corrects - -RuboCop::Cop::Style::HashConversion - reports different offense for hash argument Hash[] - reports different offense for multi-argument Hash[] - registers and corrects an offense when using argumentless `zip` with parentheses in `Hash[]` - registers and corrects an offense when using multi-argument `Hash[]` as a method argument - wraps complex statements in parens if needed - reports different offense for empty Hash[] - registers and corrects an offense when using `zip` with argument in `Hash[]` - reports different offense for Hash[a || b] - reports different offense for Hash[(a && b)] - does not try to correct multi-argument Hash with odd number of arguments - reports different offense for hash argument Hash[] as a method argument without parentheses - reports different offense for Hash[a && b] - reports an offense for single-argument Hash[] - reports different offense for hash argument Hash[] as a method argument with parentheses - reports different offense for Hash[(a || b)] - registers and corrects an offense when using argumentless `zip` without parentheses in `Hash[]` - AllowSplatArgument: true - does not register an offense for unpacked array - AllowSplatArgument: false - reports uncorrectable offense for unpacked array - -isolated environment - is not affected by a config file above the work directory - -RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier - EnforcedStyle is `only_before` - accepts blank line after public - registers an offense for blank line after private - registers an offense for missing blank line before protected - registers an offense for missing blank line before public - registers an offense for missing blank line before private - does not register an offense when `end` immediately after protected - accepts missing blank line after protected - registers an offense for missing blank line before module_function - accepts missing blank line after private - accepts blank line after module_function - registers an offense for blank line after protected - does not register an offense when `end` immediately after private - EnforcedStyle is `around` - accepts missing blank line when at the beginning of module - requires blank line after, but not before, module_function when at the beginning of class/module - requires blank line when next line started with end - requires blank line after private - ignores an accessor with the same name as protected above a method definition - accepts missing blank line when at the end of specifying `self` - recognizes blank lines with DOS style line endings - ignores private with a right-hand-side condition - accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line - ignores public inside a method call - accepts missing blank line when at the end of specifying a superclass - accepts missing blank line when at the end of block - ignores public with block argument - requires blank line after module_function - accepts missing blank line when at the end of specifying a superclass - recognizes blank lines with DOS style line endings - ignores comment line before protected - requires blank line after, but not before, public when at the beginning of class/module - accepts missing blank line when specifying a superclass that breaks the line - ignores public with a right-hand-side condition - accepts missing blank line when at the end of specifying `self` - accepts missing blank line when specifying `self` that breaks the line - ignores private inside a method call - autocorrects blank line after #{access_modifier} with comment - requires blank line after protected - accepts missing blank line when at the end of specifying a superclass - accepts only using access modifier - accepts missing blank line when at the beginning of file and preceded by a comment - accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line - ignores module_function inside a method call - accepts only using access modifier - accepts missing blank line when at the beginning of module - accepts only using access modifier - accepts missing blank line when at the end of block - accepts missing blank line when specifying a superclass that breaks the line - ignores comment line before public - requires blank line before module_function - accepts missing blank line when at the beginning of sclass - accepts missing blank line when at the beginning of class - ignores module_function with block argument - accepts missing blank line when specifying `self` that breaks the line - ignores protected with block argument - accepts missing blank line when at the end of specifying `self` - ignores an accessor with the same name as private above a method definition - ignores protected inside a method call - accepts missing blank line when specifying a superclass that breaks the line - ignores protected deep inside a method call - requires blank line before protected - ignores an accessor with the same name as public above a method definition - accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line - accepts missing blank line when at the beginning of module - ignores private deep inside a method call - accepts missing blank line when at the beginning of sclass - ignores private with block argument - accepts missing blank line when specifying a superclass that breaks the line - requires blank line after, but not before, private when at the beginning of class/module - accepts missing blank line when at the beginning of module - requires blank line after, but not before, protected when at the beginning of class/module - recognizes blank lines with DOS style line endings - autocorrects blank line after #{access_modifier} with comment - recognizes blank lines with DOS style line endings - autocorrects blank line after #{access_modifier} with comment - accepts missing blank line when at the beginning of class - ignores module_function deep inside a method call - accepts missing blank line when at the beginning of file and preceded by a comment - ignores comment line before module_function - accepts missing blank line when at the end of specifying `self` - requires blank line when next line started with end - requires blank line before public - ignores protected with a right-hand-side condition - ignores an accessor with the same name as module_function above a method definition - accepts only using access modifier - requires blank line when next line started with end - requires blank line before private - accepts missing blank line when at the beginning of sclass - accepts missing blank line when at the end of specifying a superclass - accepts missing blank line when at the beginning of filewhen specifying a superclass that breaks the line - autocorrects blank line after #{access_modifier} with comment - accepts missing blank line when specifying `self` that breaks the line - accepts missing blank line when at the beginning of file and preceded by a comment - ignores public deep inside a method call - accepts missing blank line when at the end of block - accepts missing blank line when at the beginning of class - accepts missing blank line when at the end of block - ignores module_function with a right-hand-side condition - accepts missing blank line when at the beginning of file and preceded by a comment - accepts missing blank line when specifying `self` that breaks the line - accepts missing blank line when at the beginning of class - accepts missing blank line when at the beginning of sclass - requires blank line after public - ignores comment line before private - requires blank line when next line started with end - at the beginning of block - for blocks defined with do - requires blank line after, but not before, protected - accepts missing blank line with arguments - accepts missing blank line - for blocks defined with {} - accepts missing blank line with arguments - accepts missing blank line - at the beginning of block - for blocks defined with do - requires blank line after, but not before, module_function - accepts missing blank line with arguments - accepts missing blank line - for blocks defined with {} - accepts missing blank line - accepts missing blank line with arguments - at the beginning of block - for blocks defined with {} - accepts missing blank line - accepts missing blank line with arguments - for blocks defined with do - accepts missing blank line - requires blank line after, but not before, private - accepts missing blank line with arguments - at the beginning of block - for blocks defined with do - requires blank line after, but not before, public - accepts missing blank line with arguments - accepts missing blank line - for blocks defined with {} - accepts missing blank line with arguments - accepts missing blank line - Ruby 2.7 - ignores private with numblock argument - registers an offense for missing around line before public - ignores protected with numblock argument - registers an offense for missing around line before private - ignores module_function with numblock argument - ignores public with numblock argument - registers an offense for missing around line before protected - registers an offense for missing around line before module_function - -RuboCop::Cop::InternalAffairs::CopDescription - The description starts with a word such as verb - does not register if the description like `Checks` - does not register if the description starts with non-verb word - There is no description comment - does not register offense - The description starts with `This cop ...` - registers an offense and corrects if using just a verb - registers an offense if the description like `This cop is ...` - registers an offense if using an auxiliary verb - -RuboCop::Cop::Style::SelectByRegexp - with find_all - registers an offense and corrects for `regexp =~ blockvar` - does not register an offense when the block does not match a regexp - does not register an offense when the receiver is `Hash.new` - registers an offense and corrects for `match?` - registers an offense and corrects when the receiver is an array - registers an offense and corrects with a multiline block - does not register an offense when the receiver is a hash literal - does not register an offense when the block uses an external variable in a regexp match - registers an offense and corrects when the receiver is a range - does not register an offense when given a proc - registers an offense and corrects when the receiver is a set - registers an offense and corrects when there is no explicit regexp - registers an offense and corrects for `lvar =~ blockvar` - registers an offense if `to_h` is in the receiver chain but not the actual receiver - does not register an offense when the block param is a method argument - does not register an offense when the block has multiple expressions - does not register an offense when the receiver is `Hash[]` - does not register an offense when the receiver is `ENV` - registers an offense and corrects without a receiver - does not register an offense when there is no block - does not register an offense when the block arity is not 1 - registers an offense and corrects for `blockvar =~ lvar` - does not register an offense when the receiver is `to_h` - registers an offense and corrects for `Regexp#match?` - does not register an offense when the receiver is `to_hash` - registers an offense and corrects for `blockvar =~ regexp` - with `numblock`s - does not register an offense when the param is a method argument - registers an offense and corrects for `blockvar =~ regexp` - registers an offense and corrects for `regexp =~ blockvar` - registers an offense and corrects for `match?` - does not register an offense when using `match?` without a receiver - does not register an offense if there is more than one numbered param - registers an offense and corrects for `Regexp#match?` - with select - does not register an offense when the receiver is a hash literal - does not register an offense when the block has multiple expressions - registers an offense and corrects for `lvar =~ blockvar` - does not register an offense when there is no block - registers an offense and corrects when the receiver is a set - does not register an offense when the block uses an external variable in a regexp match - registers an offense and corrects with a multiline block - does not register an offense when the block arity is not 1 - does not register an offense when given a proc - does not register an offense when the block param is a method argument - registers an offense and corrects for `blockvar =~ regexp` - does not register an offense when the receiver is `to_hash` - does not register an offense when the block does not match a regexp - registers an offense and corrects when the receiver is a range - registers an offense and corrects for `regexp =~ blockvar` - registers an offense and corrects for `blockvar =~ lvar` - does not register an offense when the receiver is `to_h` - does not register an offense when the receiver is `Hash.new` - does not register an offense when the receiver is `Hash[]` - registers an offense and corrects for `match?` - registers an offense and corrects without a receiver - registers an offense and corrects when there is no explicit regexp - registers an offense if `to_h` is in the receiver chain but not the actual receiver - registers an offense and corrects for `Regexp#match?` - registers an offense and corrects when the receiver is an array - does not register an offense when the receiver is `ENV` - with `numblock`s - registers an offense and corrects for `match?` - does not register an offense when the param is a method argument - registers an offense and corrects for `regexp =~ blockvar` - does not register an offense if there is more than one numbered param - registers an offense and corrects for `Regexp#match?` - registers an offense and corrects for `blockvar =~ regexp` - does not register an offense when using `match?` without a receiver - with reject - does not register an offense when the receiver is a hash literal - does not register an offense when the receiver is `to_h` - does not register an offense when the block param is a method argument - does not register an offense when the block does not match a regexp - does not register an offense when the receiver is `to_hash` - does not register an offense when the block has multiple expressions - registers an offense and corrects when there is no explicit regexp - registers an offense and corrects without a receiver - does not register an offense when there is no block - does not register an offense when given a proc - registers an offense and corrects for `blockvar =~ lvar` - does not register an offense when the receiver is `Hash.new` - registers an offense and corrects for `Regexp#match?` - does not register an offense when the block uses an external variable in a regexp match - registers an offense and corrects with a multiline block - registers an offense if `to_h` is in the receiver chain but not the actual receiver - registers an offense and corrects when the receiver is a set - does not register an offense when the receiver is `ENV` - does not register an offense when the block arity is not 1 - does not register an offense when the receiver is `Hash[]` - registers an offense and corrects for `match?` - registers an offense and corrects for `blockvar =~ regexp` - registers an offense and corrects for `lvar =~ blockvar` - registers an offense and corrects when the receiver is an array - registers an offense and corrects when the receiver is a range - registers an offense and corrects for `regexp =~ blockvar` - with `numblock`s - does not register an offense when the param is a method argument - registers an offense and corrects for `regexp =~ blockvar` - does not register an offense if there is more than one numbered param - does not register an offense when using `match?` without a receiver - registers an offense and corrects for `match?` - registers an offense and corrects for `Regexp#match?` - registers an offense and corrects for `blockvar =~ regexp` - -RuboCop::Cop::Layout::SpaceBeforeSemicolon - does not register an offense for no space before semicolons - registers an offense and corrects space before semicolon - registers an offense and corrects more than one space before a semicolon - inside block braces - when EnforcedStyle for SpaceInsideBlockBraces is space - accepts a space between an opening brace and a semicolon - behaves like common behavior - accepts no space between an opening brace and a semicolon - when EnforcedStyle for SpaceInsideBlockBraces is no_space - registers an offense and corrects a space between an opening brace and a semicolon - behaves like common behavior - accepts no space between an opening brace and a semicolon - heredocs + on case..in with identical bodies and assigning to a variable used in `case` condition + doesn't register an offense + when one of the case-match branches is empty + does not register an offense + on case-match without else + doesn't register an offense + on case-match with identical trailing lines + registers and corrects an offense + on case with identical bodies registers an offense and corrects + on case..when with identical bodies and assigning to a variable used in `case` condition + doesn't register an offense + on case with empty when + doesn't register an offense + on if..else with identical bodies + registers and corrects an offense + with a ternary + registers an offense + on if..else with identical trailing lines + registers and corrects an offense + with empty brace + does not raise any error + on if..else with identical bodies and assigning to a variable used in `if` condition + doesn't register an offense + on if..elsif with no else + doesn't register an offense + when one of the case branches is empty + does not register an offense RuboCop::Cop::Lint::FormatParameterMismatch - does not register an offense when using named parameters with escaped `%` + registers an offense for String#% + registers an offense when calling Kernel.format and the fields do not match + does not register an offense when single argument is not an array + does not register an offense when single argument is a hash + registers an offense if extra argument for dynamic width not given + constants do not register offenses + ignores percent right next to format string + registers an offense when there are more arguments than expected + does not register offense for `String#%` when arguments, fields match does not register an offense for format with splat argument + registers an offense when calling Kernel.sprintf and the fields do not match + finds faults even when the string looks like a HEREDOC + does not register an offense argument is the result of a message send + accepts an extra arg for dynamic width with other preceding flags accepts an extra argument for dynamic width - registers an offense for String#% - correctly ignores double percent does not register an offense when arguments and fields match - accepts an extra arg for dynamic width with other preceding flags - does not register an offense argument is the result of a message send - finds faults even when the string looks like a HEREDOC - registers an offense if extra argument for dynamic width not given + does not register an offense when using named parameters with escaped `%` + identifies correctly digits for spacing in format correctly parses different sprintf formats - registers an offense when calling Kernel.sprintf and the fields do not match - registers an offense when there are more arguments than expected - does not register an offense when single argument is not an array - does not register an offense when single argument is a hash does not register an offense for sprintf with splat argument registers an offense when there are less arguments than expected - registers an offense when calling Kernel.format and the fields do not match - constants do not register offenses - does not register offense for `String#%` when arguments, fields match - ignores percent right next to format string + correctly ignores double percent does not register an offense when using named parameters registers offense with sprintf - identifies correctly digits for spacing in format + when argument itself contains format characters and formats in format string and argument are not equal + ignores argument formatting + behaves like variables + does not register an offense for format called on a variable + does not register an offense for % called on a variable + does not register an offense for format called on a variable + when multiple arguments are called for + and a single variable argument is passed + does not register an offense + and a single send node is passed + does not register an offense when passed an empty array does not register an offense - with wildcard - does not register an offense for width - does not register an offense for multiple wildcards - does not register an offense for precision - does not register an offense for width and precision + when using (digit)$ flag + does not register an offense + does not register an offense when match between the maximum value specified by (digit)$ flag and the number of arguments + registers an offense when mismatch between the maximum value specified by (digit)$ flag and the number of arguments + when format is invalid + registers an offense behaves like variables - does not register an offense for % called on a variable does not register an offense for format called on a variable + does not register an offense for % called on a variable does not register an offense for format called on a variable when splat argument is present does not register an offense when args count is less than expected when args count is more than expected + does not register an offense for `#sprintf` does not register an offense for `#format` registers an offense for `#%` - does not register an offense for `#sprintf` - when format is invalid - registers an offense + with wildcard + does not register an offense for width + does not register an offense for multiple wildcards + does not register an offense for width and precision + does not register an offense for precision + when format is not a string literal + does not register an offense behaves like variables does not register an offense for % called on a variable does not register an offense for format called on a variable does not register an offense for format called on a variable - when format is not a string literal - does not register an offense behaves like variables - does not register an offense for format called on a variable does not register an offense for % called on a variable does not register an offense for format called on a variable - on format with %<> interpolations - and multiple arguments - registers an offense - and 1 argument - does not register an offense - when argument itself contains format characters and formats in format string and argument are not equal - ignores argument formatting + does not register an offense for format called on a variable on format with %{} interpolations and 1 argument does not register an offense @@ -20588,1329 +14937,25 @@ does not register an offense for format called on a variable does not register an offense for % called on a variable does not register an offense for format called on a variable - when multiple arguments are called for - and a single variable argument is passed - does not register an offense - and a single send node is passed - does not register an offense - when using (digit)$ flag - registers an offense when mismatch between the maximum value specified by (digit)$ flag and the number of arguments - does not register an offense when match between the maximum value specified by (digit)$ flag and the number of arguments - does not register an offense - behaves like variables - does not register an offense for % called on a variable - does not register an offense for format called on a variable - does not register an offense for format called on a variable - -RuboCop::Formatter::HTMLFormatter - outputs the cached result in HTML - outputs the result in HTML - -RuboCop::Cop::Lint::DeprecatedOpenSSLConstant - registers an offense with cipher constant and two arguments and corrects - registers an offense with cipher constant and no arguments and corrects - registers an offense with cipher constant and no arguments and corrects - does not register an offense with cipher constant and argument is a constant - registers an offense with cipher constant and `cbc` argument and corrects - registers an offense with cipher constant and no arguments and corrects - registers an offense with cipher constant and double quoted string argument and corrects - registers an offense when using an digest constant with chained methods and corrects - does not register an offense with cipher constant and send argument is a method - registers an offense when using ::Digest class methods on an algorithm constant and corrects - does not register an offense when using ::Digest class methods with an algorithm string and value - does not register an offense when building digest using an algorithm string - registers an offense with cipher constant and no arguments and corrects - does not register an offense with cipher constant and argument is a variable - registers an offense with cipher constant and one argument and corrects - does not register an offense when building digest using an algorithm string and nested digest constants - does not register an offense when using cipher with a string - registers an offense when building an instance using an digest constant and corrects - registers an offense with AES + blocksize constant and mode argument and corrects - registers an offense with AES + blocksize constant and corrects - when used in a block - registers an offense when using ::Digest class methods on an algorithm constant and corrects - -RuboCop::Cop::Lint::NonDeterministicRequireOrder - when not requiring files - does not register an offense - when requiring files - with sorted index - does not register an offense - when Ruby 3.0 or higher - with direct block glob - does not register an offense - with top-level ::Dir - does not register an offense - with require block passed as parameter - does not register an offense - with `Dir.glob` - does not register an offense - with `sort: false` keyword option - does not register an offense - with require block passed as parameter - does not register an offense - with top-level ::Dir - does not register an offense - with `Dir[]` - does not register an offense - with require block passed as parameter - does not register an offense - with top-level ::Dir - does not register an offense - with extra logic - does not register an offense - when Ruby 2.7 or lower - with direct block glob - registers an offense and autocorrects to add .sort.each - with require_relative block passed as parameter - registers an offense and autocorrects to add sort - with require block passed as parameter - registers an offense and autocorrects to add sort - with top-level ::Dir - registers an offense and corrects to add .sort.each - with unsorted index - registers an offense and autocorrects to add .sort when the numblock has `require` - registers an offense and autocorrects to add .sort when the block has `require` - registers an offense and autocorrects to add .sort when the block has `require_relative` - registers an offense with extra logic - with require block passed as parameter - registers an offense an autocorrects to add sort - with require_relative block passed as parameter - registers an offense an autocorrects to add sort - with top-level ::Dir - registers an offense and corrects to add .sort - with unsorted glob - registers an offense and autocorrects to add .sort - with top-level ::Dir - registers an offense and corrects to add .sort - with require block passed as parameter - registers an offense an autocorrects to add sort - with sorted glob - does not register an offense - -RuboCop::Cop::Lint::AmbiguousOperator - with `-` unary operator in the first argument - with parentheses around the operator - does not register an offense - without parentheses - without whitespaces on the right of the operator - registers an offense and corrects - with a whitespace on the right of the operator - does not register an offense - with a keyword splat operator in the first argument - without parentheses - with a whitespace on the right of the operator - does not register an offense - without whitespaces on the right of the operator - registers an offense and corrects - with parentheses around the keyword splat operator - does not register an offense - with a block ampersand in the first argument - without parentheses - with a whitespace on the right of the operator - does not register an offense - without whitespaces on the right of the operator - registers an offense and corrects - with parentheses around the block argument - does not register an offense - with a splat operator in the first argument - without parentheses - with a whitespace on the right of the operator - does not register an offense - without whitespaces on the right of the operator - registers an offense and corrects - with parentheses around the splatted argument - does not register an offense - when using safe navigation operator with a unary operator - does not register an offense - with `+` unary operator in the first argument - without parentheses - with a whitespace on the right of the operator - does not register an offense - without whitespaces on the right of the operator when a method with no arguments is used in advance - registers an offense and corrects - without whitespaces on the right of the operator - registers an offense and corrects - with parentheses around the operator - does not register an offense - -RuboCop::Cop::Lint::AmbiguousRegexpLiteral - Ruby >= 3.0 - with parentheses - accepts - without parentheses - registers an offense and corrects when single argument - registers an offense and corrects when sending method chain to regexp - registers an offense and corrects when using block argument - registers an offense and corrects when sending method without receiver takes a regexp argument - registers an offense and corrects when sending method inside parens without receiver takes a regexp argument - registers an offense and corrects when using nested method arguments without parentheses - registers an offense and corrects when multiple arguments - registers an offense and corrects when nesting - registers an offense and corrects when sending method to regexp with argument - registers an offense and corrects when sending method to regexp without argument - registers an offense and corrects when using regexp without method call in a nested structure - with `match_with_lvasgn` node - with different parentheses - does not register an offense - with parentheses - does not register an offense - without parentheses - registers an offense and corrects - Ruby <= 2.7 - without parentheses - registers an offense and corrects when sending method to regexp without argument - registers an offense and corrects when sending method to regexp with argument - registers an offense and corrects when sending method chain to regexp - registers an offense and corrects when sending method without receiver takes a regexp argument - registers an offense and corrects when single argument - registers an offense and corrects when using block argument - registers an offense and corrects when using regexp without method call in a nested structure - registers an offense and corrects when sending method inside parens without receiver takes a regexp argument - registers an offense and corrects when nesting - registers an offense and corrects when using nested method arguments without parentheses - registers an offense and corrects when multiple arguments - with parentheses - accepts - with `match_with_lvasgn` node - with parentheses - does not register an offense - with different parentheses - does not register an offense - without parentheses - registers an offense and corrects - -RuboCop::Cop::Style::Send - with __send__ - and with a receiver - does not register an offense for an invocation with args - does not register an offense for an invocation without args - and without a receiver - does not register an offense for an invocation without args - does not register an offense for an invocation with args - with public_send - and without a receiver - does not register an offense for an invocation without args - does not register an offense for an invocation with args - and with a receiver - does not register an offense for an invocation with args - does not register an offense for an invocation without args - with send - and with a receiver - does not register an offense for an invocation without args - registers an offense for an invocation with args - when using safe navigation operator - registers an offense for an invocation with args - and without a receiver - registers an offense for an invocation with args - does not register an offense for an invocation without args - -RuboCop::Cop::Lint::LambdaWithoutLiteralBlock - does not register an offense when using lambda with a literal block - registers and corrects an offense when using lambda with a proc variable block argument - does not register an offense when using lambda with a symbol proc - registers and corrects an offense when using lambda with `&proc {}` block argument - registers and corrects an offense when using lambda with `&Proc.new {}` block argument - does not register an offense when using `lambda.call` - -RuboCop::Cop::Layout::ClassStructure - registers an offense and corrects when xstr heredoc constant is defined after public method - registers an offense and corrects when dstr heredoc constant is defined after public method - registers an offense and corrects when str heredoc constant is defined after public method - registers an offense and corrects when there is a comment in the macro method - registers an offense and corrects when literal constant is after method definitions - with protected methods declared before private - is expected to eq class MyClass - def public_method - end - - private - - def first_private...ar before `private_methods`. - end - - def second_protected_method - end - end - initializer is private and comes after attribute macro - registers an offense and autocorrects - when def modifier is used - registers an offense and corrects public method without modifier declared after private method with modifier - registers an offense and corrects public method with modifier declared after private method with modifier - registers an offense and corrects public method after private method marked by its name - with a complete ordered example - does not create offense - with attribute macros before after validations - is expected to eq class Person - include AnotherModule - extend SomeModule - - CustomError = Cla...rivate :other_public_method - - private - - def some_private_method - end - end - constant is not a literal - registers offense but does not autocorrect - simple example - is expected to eq "class Person\n include AnotherModule\n extend SomeModule\n CONST = 'wrong place'\nend\n" - when the first line ends with a comment - reports an offense and swaps the lines - -RuboCop::Cop::Style::FloatDivision - EnforcedStyle is left_coerce - does not register offense for left coerce - registers offense and corrects for right coerce with calculations - registers offense and corrects for both coerce - registers offense and corrects for right coerce - EnforcedStyle is single_coerce - registers offense and corrects for both coerce - registers offense and corrects for left coerce with calculations - does not register offense for left coerce only - does not register offense for right coerce only - EnforcedStyle is fdiv - registers offense and corrects for both coerce - registers offense and corrects for left coerce - does not register offense on usage of fdiv - registers offense and corrects for left coerce with calculations - registers offense and corrects for right coerce - EnforcedStyle is right_coerce - registers offense and corrects for left coerce - does not register offense for right coerce - registers offense and corrects for both coerce - registers offense and corrects for left coerce with calculations - -RuboCop::Cop::Style::MagicCommentFormat - invalid config - ValueCapitalization - raises an error - DirectiveCapitalization - raises an error - all issues at once - registers and corrects multiple issues - snake case style - accepts a frozen string literal in snake case in emacs style - accepts a magic comments in snake case - accepts a source with no tokens - does not register an offense for dashes in other comments - registers an offense for kebab case - does not register an offense for incorrect style in comments after the first statement - accepts an empty source - registers an offense for kebab case in emacs style - registers an offense for mixed case - kebab case style - accepts an empty source - accepts a source with no tokens - registers an offense for snake case - accepts a magic comments in kebab case - registers an offense for mixed case - registers an offense for snake case in emacs style - does not register an offense for dashes in other comments - does not register an offense for incorrect style in comments after the first statement - accepts a frozen string literal in snake case in emacs style - DirectiveCapitalization - when lowercase - registers an offense and corrects when the case does not match - when uppercase - registers an offense and corrects when the case does not match - when not set - does not change the case of magic comment directives - ValueCapitalization - when not set - does not change the case of magic comment directives - when uppercase - registers an offense and corrects when the case does not match - when lowercase - registers an offense and corrects when the case does not match - -RuboCop::Cop::Style::CollectionMethods - registers an offense for detect with block - registers an offense for find_all with block - registers an offense for collect with block - accepts member? without a block - registers an offense for member? with proc param - registers an offense for find_all with proc param - registers an offense for collect with an argument and proc param - registers an offense for detect with an argument and proc param - registers an offense for member? with an argument and proc param - registers an offense for detect with proc param - accepts collect without a block - registers an offense for inject with block - accepts inject without a block - registers an offense for member? with block - accepts find_all without a block - registers an offense for find_all with an argument and proc param - registers an offense for inject with an argument and proc param - registers an offense for collect with proc param - accepts detect without a block - registers an offense for inject with proc param - for methods that accept a symbol as implicit block - registers an offense with an argument and final symbol param - registers an offense with a final symbol param - Ruby 2.7 - registers an offense for member? with numblock - Ruby 2.7 - registers an offense for detect with numblock - for methods that do not accept a symbol as implicit block - does not register an offense for a final symbol param with extra args - does not register an offense for a final symbol param - Ruby 2.7 - registers an offense for collect with numblock - Ruby 2.7 - registers an offense for inject with numblock - Ruby 2.7 - registers an offense for find_all with numblock - -RuboCop::Cop::Style::RedundantCondition - when inverted condition (unless) - registers no offense - when condition and else branch are same - accepts complex unless branches - registers an offense - when regular condition (if) - accepts different when the condition does not match the branch - accepts elsif - when condition and if_branch are same - does not register an offense when using assignment by hash key access - does not register an offense when the branches are the same with different receivers - accepts complex else branches - registers an offense and corrects when the branches contains assignment method - registers an offense and corrects when the branches contains parenthesized method call - registers an offense and correct when the branches are the same with the same receivers - registers an offense and corrects when the else branch contains an irange - registers an offense and corrects - registers an offense and corrects when the branches contains method call - accepts when using ternary if in `else` branch - registers an offense and corrects when the branches contains method call with non-braced hash - registers an offense and corrects when `raise` without argument parentheses in `else` - registers an offense and corrects when using operator method in `else` - registers an offense and corrects when the branches contains method call with braced hash - registers an offense and corrects when `if` condition and `then` branch are the same and it has no `else` branch - accepts an elsif branch - registers an offense and corrects modifier nodes offense - registers an offense and corrects when the branches contains assignment - registers an offense and corrects when the branches contains arithmetic operation - registers an offense and corrects multiline nodes - registers an offense and corrects when using modifier if - autocorrects when using `<<` method higher precedence than `||` operator - registers an offense and corrects complex one liners - does not register offenses when using `nil?` and the branches contains method which has multiple arguments - does not register offenses when the branches contains hash key access - registers an offense and corrects when defined inside method and the branches contains assignment - registers an offense and corrects when a method without argument parentheses in `else` - does not register offenses when the branches contains assignment but target not matched - does not register offenses when using `nil?` and the branches contains assignment - ternary expression (?:) - accepts expressions when the condition and if branch do not match - when condition and if_branch are same - registers an offense and corrects nested vars - registers an offense and corrects with ternary expression and the branches contains parenthesized method call - registers an offense and corrects when the else branch contains an irange - registers an offense and corrects when the else branch contains `rescue` - registers an offense and corrects with ternary expression and the branches contains chained parenthesized method call - registers an offense and corrects when the else branch contains `and` - registers an offense and corrects class vars - registers an offense and corrects when the else branch contains an erange - registers an offense and corrects - registers an offense and corrects brackets accesses - registers an offense and corrects functions - -RuboCop::Cop::Generator - compliance with rubocop - generates a cop file that has no offense (PENDING: Temporarily skipped with xit) - generates a spec file that has no offense (PENDING: Temporarily skipped with xit) - #snake_case - converts "FooBar" to snake_case - converts "RSpec" to snake_case - converts "FooBar/Baz" to snake_case - converts "RSpecFoo/Bar" to snake_case - converts "Lint" to snake_case - converts "RSpec/Foo" to snake_case - #write_spec - refuses to overwrite existing files - generates a helpful starting spec file with the class filled in - .new - does not accept an unqualified cop - nested departments - generates source and spec files correctly namespaced within departments - #write_source - generates a helpful source file with the name filled in - refuses to overwrite existing files - #inject_config - when it is the first in alphabetical order - inserts the cop - when it is the last in alphabetical order - inserts the cop - with version provided - uses the provided version - when it is the middle in alphabetical order - inserts the cop - #todo - provides a checklist for implementing the cop - -RuboCop::Cop::Style::MultilineTernaryOperator - registers an offense and corrects when condition is multiline - registers an offense and corrects when everything is on a separate line - register an offense and corrects when returning a multiline ternary operator expression with `next` - register an offense and corrects when returning a multiline ternary operator expression with method call - registers an offense and corrects when condition is multiline and using assignment method - accepts a single line ternary operator expression - registers an offense and corrects when the false branch is on a separate line - register an offense and corrects when returning a multiline ternary operator expression with `break` - register an offense and corrects when returning a multiline ternary operator expression with `return` - registers offense and corrects when the if branch and the else branch are on a separate line from the condition - registers an offense and corrects when condition is multiline and using hash key assignment - registers an offense and corrects when the false branch is on a separate line and assigning a return value - -RuboCop::Cop::Style::EmptyCaseCondition - given a case statement with an empty case - with a when branch including comma-delimited alternatives - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - with when branches using then - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - when using `return` in `when` clause and assigning the return value of `case` - does not register an offense - when using `return ... if` in `when` clause and assigning the return value of `case` - does not register an offense - with a single when branch and no else - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - when using `when ... then` in `case` in a method call - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - when using `when ... then` in `case` in `return` - behaves like detect/correct empty case, accept non-empty case - accepts the source with case - registers an offense and autocorrects - when using `return` in `else` clause and assigning the return value of `case` - does not register an offense - with multiple when branches and an `else` with code comments - behaves like detect/correct empty case, accept non-empty case - accepts the source with case - registers an offense and autocorrects - with multiple when branches and no else - behaves like detect/correct empty case, accept non-empty case - accepts the source with case - registers an offense and autocorrects - with first when branch including comma-delimited alternatives - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - when used as an argument of a method with comment - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - when using `return ... if` in `else` clause and assigning the return value of `case` + on format with %<> interpolations + and 1 argument does not register an offense - with multiple when branches and an else - behaves like detect/correct empty case, accept non-empty case - registers an offense and autocorrects - accepts the source with case - with a single when branch and an else - behaves like detect/correct empty case, accept non-empty case - accepts the source with case - registers an offense and autocorrects - when used as an argument of a method without comment - behaves like detect/correct empty case, accept non-empty case - accepts the source with case - registers an offense and autocorrects - -RuboCop::Cop::Layout::EmptyLineAfterGuardClause - registers an offense and corrects a `raise` guard clause not followed by empty line when guard clause is after method call with argument - accepts multiple guard clauses - accepts a guard clause that is after a multiline heredoc with chained calls - accepts a guard clause followed by end - accepts using guard clause is after `raise` - registers an offense and corrects a guard clause not followed by empty line when guard clause including heredoc - does not register an offense when the clause ends with a semicolon but is followed by a newline - registers an offense and corrects a `raise` guard clause not followed by empty line when `unless` condition is after heredoc - accepts a guard clause after a single line heredoc - accepts using guard clause is after `rubocop:enable` comment - accepts a guard clause when the next line is `elsif` - registers an offense and corrects when using `and return` before guard condition - registers no offenses using heredoc with `and return` before guard condition with empty line - registers an offense and corrects a guard clause not followed by empty line - registers and corrects when using guard clause is after `rubocop:enable` comment - registers an offense when the clause ends with a semicolon but the next clause is on the next line - registers and corrects when using guard clause is after `rubocop:disable` comment - registers an offense and corrects `next` guard clause not followed by empty line - does not register an offense when there are multiple clauses on the same line - registers an offense and corrects a `raise` guard clause not followed by empty line when `if` condition is after heredoc - accepts modifier if - accepts a guard clause when the next line is `else` - accepts a guard clause that is after a multiline heredoc nested argument call - registers an offense and corrects a guard clause is before `begin` - accepts a guard clause when the next line is `rescue` - registers an offense and corrects a guard clause that is a ternary operator - accepts a guard clause when the next line is `rescue`-`else` - accepts a modifier if when the next line is `end` - accepts a guard clause that is after multiline heredoc - accepts a guard clause followed by empty line when guard clause including heredoc - accepts a guard clause inside oneliner block - does not register an offense when the clause is not followed by other code - registers an offense and corrects only the last guard clause - registers an offense and corrects a method starting with end_ - registers an offense and corrects a next guard clause not followed by empty line when guard clause is after heredoc including string interpolation - registers an offense and corrects using heredoc with `and return` before guard condition - registers an offense and corrects when using `or return` before guard condition - accepts a guard clause when the next line is `ensure` - accepts a `raise` guard clause not followed by empty line when guard clause is after condition without method invocation - -RuboCop::Cop::Style::EmptyBlockParameter - accepts a non-empty block parameter with {} style - registers an offense for an empty block parameter with super - accepts a block that is do-end style without parameter - accepts a block that is {} style without parameter - registers an offense for an empty block parameter with {} style - accepts a non-empty block parameter with do-end style - registers an offense for an empty block parameter with lambda - accepts an empty block parameter with a lambda - registers an offense for an empty block parameter with do-end style - -RuboCop::Cop::Layout::MultilineHashKeyLineBreaks - without line break after opening bracket - registers an offense and corrects when key starts on same line as another - registers an offense and corrects nested hashes - when on same line - does not add any offenses - with line break after opening bracket - registers an offense and corrects when key starts on same line as another - when key starts on same line as another with rockets - adds an offense - when on all keys on one line different than brackets - does not add any offenses - when on different lines than brackets but keys on one - does not add any offenses - -RuboCop::Cop::Layout::SpaceAfterColon - accepts colons in strings - registers an offense and corrects colon without space after it - accepts hash rockets - accepts required keyword arguments - accepts if - accepts hashes with a space after colons - accepts colons denoting required keyword argument - registers an offense and corrects a keyword optional argument without a space - accepts colon in ternary followed by space - accepts colons in symbols - Ruby >= 3.1 - does not register an offense colon without space after it when using hash value omission - accepts colons denoting hash value omission argument - -RuboCop::TargetRuby - when TargetRubyVersion is set - does not read Gemfile.lock or gems.locked - uses TargetRubyVersion - does not read .ruby-version - when TargetRubyVersion is not set - when .ruby-version is in a parent directory - reads it to determine the target ruby version - when .ruby-version is not present - and gems.locked exists - uses MRI Ruby version when it is present in gems.locked - uses the default Ruby when jruby is in gems.locked - uses the default Ruby when rbx is in gems.locked - uses MRI Ruby version when it has multiple digits - uses the default Ruby when Ruby is not in gems.locked - when bundler lock files are not present - uses the default target ruby version - gemspec file - when file contains `required_ruby_version` as a string - sets target_ruby from exclusive range - sets target_ruby from inclusive range - sets target_ruby from approximate version - when file does not contain `required_ruby_version` - sets default target_ruby - when file contains `required_ruby_version` as a requirement - sets first known ruby version that satisfies requirement - sets target_ruby from required_ruby_version from inclusive requirement range - when file contains `required_ruby_version` as an array - sets target_ruby from required_ruby_version with many requirements - sets target_ruby to the minimal version satisfying the requirements - and Gemfile.lock exists - uses the default Ruby when Ruby is not in Gemfile.lock - uses MRI Ruby version when it is present in Gemfile.lock - uses MRI Ruby version when it has multiple digits - uses the default Ruby when rbx is in Gemfile.lock - uses the default Ruby when jruby is in Gemfile.lock - when .ruby-version is not in a parent directory - when gems.locked is in a parent directory - does - when Gemfile.lock is in a parent directory - does - when .ruby-version is present - does not read .tool-versions, Gemfile.lock or gems.locked - when the MRI version contains multiple digits - reads it to determine the target ruby version - when .ruby-version contains an MRI version - reads it to determine the target ruby version - when .ruby-version contains "system" version - uses the default target ruby version - when .ruby-version contains a Rbx version - uses the default target ruby version - when .ruby-version contains a version prefixed by "ruby-" - correctly determines the target ruby version - when .ruby-version contains a JRuby version - uses the default target ruby version - when .tool-versions is present - when .tool-versions contains a ruby version - reads it to determine the target ruby version - does not read Gemfile.lock, gems.locked - when .tool-versions does not contain a ruby version - uses the default ruby version - -RuboCop::Cop::Registry - exposes the number of stored cops - can be cloned - can filter down to one type - exposes a mapping of cop names to cop classes - exposes cop departments - can filter down to all but one type - exposes a list of cop names - #enabled - selects only safe cops if :safe passed - overrides config if :only includes the cop - selects cops which are enabled in the config - when new cops are introduced - overrides config if :only includes the cop - does not include them - when specifying `--enable-pending-cops` command-line option - includes them - when specifying `NewCops: disable` option in .rubocop.yml - includes them because command-line option takes precedence over .rubocop.yml - when specifying `NewCops: enable` option in .rubocop.yml - includes them - when specifying `NewCops: pending` option in .rubocop.yml - does not include them - when specifying `--disable-pending-cops` command-line option - does not include them - when specifying `NewCops: enable` option in .rubocop.yml - does not include them because command-line option takes precedence over .rubocop.yml - when specifying `NewCops: disable` option in .rubocop.yml - does not include them - #contains_cop_matching? - can find cops matching a given name - returns false for cops not included in the store - #cops - exposes a list of cops - with cops having the same inner-most module - exposes both cops - names_for_department - returns array of cops for specified department - when dismissing a cop class - allows re-listing - disallows it if done too late - allows it if done rapidly - #department? - returns false for other names - returns true for department name - #qualified_cop_name - returns the provided name if no namespace is found - qualifies names without a namespace - gives back already properly qualified names - qualifies names with the correct namespace - emits a warning when namespace is incorrect - raises an error when a cop name is ambiguous - -RuboCop::Cop::Lint::UnreachableCode - accepts `retry` is in `if`, and without `else` - registers an offense for `abort` in all `if` and `elsif` branches - registers an offense for `break` in all `case` branches - registers an offense for `break` before other statements - accepts `throw` is in `case` branch without else - registers an offense for `exit!` in all `case` branches - registers an offense for `fail` in all `if` and `elsif` branches - accepts `break` is in `case` branch without else - accepts `exit` as the final expression - accepts `return` is in `if` branch only - accepts `exit` is in `case` branch without else - registers an offense for `exit` before other statements - registers an offense for `fail` in all `if` branches with other expressions - accepts `next` is in `case` branch without else - accepts `break` is in `if`, and without `else` - registers an offense for `next` in all `if` and `elsif` branches - accepts `exit` is in `else` branch only - accepts `exit` is in all `if` branches - registers an offense for `abort` in all `if` branches - accepts `fail` is in `case` branch without else - registers an offense for `raise` before other statements - accepts `raise` is in all `if` branches - accepts code with conditional `throw` - registers an offense for `retry` in all `if` and `elsif` branches - accepts `fail` is in `if`, and without `else` - accepts `exit!` is in all `if` branches - registers an offense for `exit` in all `if` branches with other expressions - accepts `abort` is in `if`, and without `else` - registers an offense for `retry` in `begin` - registers an offense for `redo` in all `if` branches with other expressions - accepts `redo` is in `if`, and without `else` - accepts `break` is in `if` branch only - registers an offense for `next` in `begin` - registers an offense for `next` in all `case` branches - accepts `raise` as the final expression - accepts `abort` is in `else` branch only - registers an offense for `throw` in all `if` branches - registers an offense for `return` before other statements - accepts `exit!` is in `case` branch without else - registers an offense for `throw` in all `if` branches with other expressions - accepts `break` is in all `if` branches - accepts `abort` is in `if` branch only - accepts `retry` as the final expression - accepts `exit!` as the final expression - accepts code with conditional `break` - accepts `break` as the final expression - accepts `raise` is in `case` branch without else - accepts `abort` as the final expression - registers an offense for `retry` before other statements - accepts `exit` is not in `elsif` branch - registers an offense for `throw` in all `case` branches - accepts `break` is not in `elsif` branch - accepts code with conditional `exit!` - accepts `next` is in `else` branch only - accepts `raise` is not in `elsif` branch - registers an offense for `next` before other statements - registers an offense for `throw` in `begin` - registers an offense for `exit!` before other statements - registers an offense for `break` in `begin` - accepts `fail` is in all `if` branches - accepts `exit` is in `if` branch only - registers an offense for `abort` in all `case` branches - accepts `next` as the final expression - accepts `return` is in `case` branch without else - accepts `exit!` is in `else` branch only - registers an offense for `abort` before other statements - accepts `redo` is in `case` branch without else - accepts `retry` is in `else` branch only - accepts `next` is in all `if` branches - accepts `return` as the final expression - registers an offense for `raise` in all `case` branches - registers an offense for `redo` before other statements - accepts `fail` is not in `elsif` branch - registers an offense for `exit` in all `if` and `elsif` branches - accepts `next` is in `if`, and without `else` - accepts `retry` is in `if` branch only - accepts `throw` is in `if` branch only - registers an offense for `next` in all `if` branches - accepts `exit!` is not in `elsif` branch - registers an offense for `exit!` in all `if` and `elsif` branches - accepts `redo` as the final expression - registers an offense for `break` in all `if` branches with other expressions - registers an offense for `return` in all `if` branches with other expressions - accepts `retry` is in all `if` branches - registers an offense for `fail` in all `case` branches - accepts `abort` is in all `if` branches - accepts `return` is not in `elsif` branch - registers an offense for `next` in all `if` branches with other expressions - accepts `break` is in `else` branch only - registers an offense for `retry` in all `if` branches - accepts code with conditional `next` - registers an offense for `return` in all `if` branches - registers an offense for `redo` in `begin` - accepts `return` is in `if`, and without `else` - registers an offense for `retry` in all `if` branches with other expressions - accepts code with conditional `raise` - accepts code with conditional `exit` - registers an offense for `retry` in all `case` branches - accepts code with conditional `redo` - accepts code with conditional `abort` - accepts `throw` as the final expression - accepts `abort` is not in `elsif` branch - accepts `redo` is in `if` branch only - accepts `next` is in `if` branch only - registers an offense for `exit!` in `begin` - accepts `throw` is in `if`, and without `else` - registers an offense for `exit` in all `case` branches - registers an offense for `raise` in `begin` - registers an offense for `raise` in all `if` branches with other expressions - registers an offense for `exit!` in all `if` branches with other expressions - accepts code with conditional `fail` - accepts `fail` as the final expression - accepts `retry` is not in `elsif` branch - registers an offense for `fail` in all `if` branches - accepts `fail` is in `if` branch only - registers an offense for `return` in `begin` - registers an offense for `fail` in `begin` - registers an offense for `throw` in all `if` and `elsif` branches - accepts `redo` is in all `if` branches - registers an offense for `fail` before other statements - registers an offense for `abort` in all `if` branches with other expressions - accepts code with conditional `retry` - accepts `fail` is in `else` branch only - registers an offense for `redo` in all `if` and `elsif` branches - registers an offense for `throw` before other statements - accepts `redo` is in `else` branch only - registers an offense for `raise` in all `if` and `elsif` branches - accepts `throw` is in all `if` branches - registers an offense for `break` in all `if` and `elsif` branches - accepts `return` is in all `if` branches - accepts `throw` is not in `elsif` branch - accepts `exit!` is in `if` branch only - accepts `return` is in `else` branch only - accepts `raise` is in `else` branch only - accepts `raise` is in `if`, and without `else` - registers an offense for `return` in all `case` branches - accepts `raise` is in `if` branch only - accepts code with conditional `return` - accepts `retry` is in `case` branch without else - registers an offense for `abort` in `begin` - registers an offense for `exit` in `begin` - registers an offense for `return` in all `if` and `elsif` branches - registers an offense for `raise` in all `if` branches - registers an offense for `redo` in all `case` branches - accepts `redo` is not in `elsif` branch - registers an offense for `exit!` in all `if` branches - accepts `throw` is in `else` branch only - accepts `abort` is in `case` branch without else - accepts `exit` is in `if`, and without `else` - registers an offense for `exit` in all `if` branches - accepts `next` is not in `elsif` branch - accepts `exit!` is in `if`, and without `else` - registers an offense for `break` in all `if` branches - registers an offense for `redo` in all `if` branches - -RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition - does not register an offense when new line after `if` with multiline condition - does not register an offense when new line after `rescue` with multiline exceptions - does not register an offense for `when` with singleline condition - registers an offense when no new line after `elsif` with multiline condition - registers an offense when no new line after `when` with multiline condition - registers an offense when no new line after modifier `if` with multiline condition - does not register an offense when new line after modifier `while` with multiline condition - does not register an offense for `if` with single line condition - does not register an offense when modifier `if` with multiline conditionis the last child of its parent - does not register an offense when new line after `when` with multiline condition - registers an offense when no new line after `rescue` with multiline exceptions - does not register an offense when modifier `while` with multiline conditionis the last child of its parent - does not register an offense when new line after `while` with multiline condition - registers an offense when no new line after `while` with multiline condition - does not register an offense when new line after modifier `if` with multiline condition - does not register an offense when `if` at the top level - registers an offense when no new line after `until` with multiline condition - registers an offense when no new line after modifier `while` with multiline condition - registers an offense when no new line after `if` with multiline condition - does not register an offense when new line after `elsif` with multiline condition - does not register an offense for `while` with single line condition - does not register an offense for `rescue` with singleline exceptions - -RuboCop::Cop::Lint::DeprecatedClassMethods - prefer `Dir.exist?` over `Dir.exists?` - registers an offense and corrects Dir.exists? - registers an offense and corrects ::Dir.exists? - does not register an offense for offensive method `exists?`on other receivers - does not register an offense for Dir.exist? - prefer `Addrinfo#getnameinfo` over `Socket.gethostbyaddr` - registers an offense for Socket.gethostbyaddr - registers an offense for ::Socket.gethostbyaddr - does not register an offense for method `gethostbyaddr` on other receivers - prefer `File.exist?` over `File.exists?` - does not register an offense for File.exist? - registers an offense and corrects ::File.exists? - registers an offense and corrects File.exists? - prefer `block_given?` over `iterator?` - does not register an offense for offensive method `iterator?`on other receivers - registers an offense and corrects iterator? - does not register an offense for block_given? - prefer `Addrinfo#getaddrinfo` over `Socket.gethostbyname` - registers an offense for Socket.gethostbyname - does not register an offense for method `gethostbyname` on other receivers - registers an offense for ::Socket.gethostbyname - when using `ENV.dup` - does not register an offense for method calls to `ENV` other than `dup` - registers an offense - when using `ENV.freeze` - registers an offense - does not register an offense for method calls to `ENV` other than `freeze` - when using `ENV.clone` - does not register an offense for method calls to `ENV` other than `clone` - registers an offense - -RuboCop::Cop::Metrics::MethodLength - is not fooled by one-liner methods, syntax #2 - accepts a method with less than 5 lines - is not fooled by one-liner methods, syntax #1 - does not count commented lines by default - accepts empty methods - properly counts lines when method ends with block - does not count blank lines - accepts a method with multiline arguments and less than 5 lines of body - when methods to allow are defined - AllowedMethods is enabled - still rejects other methods with more than 5 lines - accepts the foo method with more than 5 lines - AllowedPatterns is enabled - accepts the user_name method - raises offense for firstname - when CountComments is enabled - also counts commented lines - when method is a class method - registers an offense - when method is defined on a singleton class - registers an offense - when `CountAsOne` is not empty - folds array into one line - when using numbered parameter - when method is defined with `define_method` - registers an offense - when method is defined with `define_method` - registers an offense - when method is an instance method - registers an offense - -RuboCop::Cop::InternalAffairs::StyleDetectedApiUse - registers an offense when unexpected_style_detected is used in a conditional expression - does not register an offense when correct_style_detected and a ambiguous_style_detected are both used - does not register an offense when correct_style_detected and a opposite_style_detected are both used - does not register an offense when correct_style_detected and a unexpected_style_detected are both used - registers an offense when correct_style_detected is used without a negative *_style_detected follow up - does not register an offense when correct_style_detected and a no_acceptable_style! are both used - registers an offense when correct_style_detected is used in a conditional expression - does not register an offense when correct_style_detected and a unrecognized_style_detected are both used - registers an offense when opposite_style_detected is used without a correct_style_detected follow up - does not register an offense when correct_style_detected and a conflicting_styles_detected are both used - registers an offense when conflicting_styles_detected is used without a correct_style_detected follow up - registers an offense when conflicting_styles_detected is used in a conditional expression - registers an offense when unrecognized_style_detected is used in a conditional expression - registers an offense when no_acceptable_style! is used in a conditional expression - registers an offense when ambiguous_style_detected is used without a correct_style_detected follow up - registers an offense when unexpected_style_detected is used without a correct_style_detected follow up - registers an offense when opposite_style_detected is used in a conditional expression - registers an offense when unrecognized_style_detected is used without a correct_style_detected follow up - registers an offense when ambiguous_style_detected is used in a conditional expression - registers an offense when no_acceptable_style! is used without a correct_style_detected follow up - -RuboCop::Cop::Metrics::Utils::CodeLengthCalculator - #calculate - raises when unknown foldable type is passed - when method - folds hashes if asked - folds arrays if asked - counts single line hash with other args correctly if asked folding - counts single line hash as the one of method args with safe navigation operator if asked folding - folds multiline hashes without braces as method args if asked - folds hashes without braces as the one of method args if asked - folds multiline hashes with line break before it as method args if asked - calculates method length - folds multiline hashes with line break after it as method args if asked - folds hashes as method args if asked - counts single line hash with line breaks correctly if asked folding - counts single line correctly if asked folding - counts single line without parentheses correctly if asked folding - folds heredocs if asked - counts single line hash as the one of method args if asked folding - folds hashes with comment if asked - does not count blank lines - counts comments if asked - folds hashes as method kwargs if asked - when class - does not count lines of inner classes - folds heredocs if asked - folds hashes if asked - does not count blank lines - folds arrays if asked - calculates class length - counts comments if asked - -RuboCop::Cop::Style::BlockComments - autocorrects a block comment into a regular comment - autocorrects an empty block comment by removing it - accepts regular comments - autocorrects a block comment into a regular comment (without trailingnewline) - registers an offense for block comments - -RuboCop::Cop::Style::ModuleFunction - when enforced style is `forbidden` - registers an offense for `module_function` without an argument - accepts `extend self` in a class - registers an offense for `extend self` - in a module with private methods - in a module - in a module with declarative private - when enforced style is `module_function` - accepts `extend self` in a class - registers an offense for `extend self` in a module - accepts for `extend self` in a module with declarative private - accepts for `extend self` in a module with private methods - when enforced style is `extend_self` - accepts module_function with an argument - registers an offense for `module_function` without an argument - -RuboCop::Cop::Lint::HeredocMethodCallPosition - correct cases - ignores if no call - accepts simple correct case - accepts chained correct case - incorrect cases - simple incorrect case - detects - chained case with parens - detects - chained case no parens - detects - chained case with multiple line args - detects - simple incorrect case with paren - detects - with trailing comma in method call - detects - chained case without args - detects - -RuboCop::Cop::Lint::ToJSON - registers an offense and corrects using `#to_json` without arguments - does not register an offense when using `#to_json` with arguments - -RuboCop::Cop::Lint::Syntax - .offenses_from_processed_source - with a parser error - returns an offense - with --display-cop-names option - returns an offense with cop name - with a diagnostic error - returns an offense - with --autocorrect --disable-uncorrectable options - returns an offense - with --display-cop-names option - returns an offense with cop name - -RuboCop::Cop::Style::EmptyHeredoc - registers an offense when using empty `<<-EOS` heredoc - does not register an offense when using not empty heredoc - registers an offense when using empty `<<~EOS` heredoc - registers an offense when using empty heredoc argument with other argument - registers an offense when using empty `<= 2.7 - accepts a single line numblock with braces - accepts a multi-line numblock that needs braces to be valid ruby - registers an offense for a single line numblock with do-end - accepts a multi-line numblock with do-end - EnforcedStyle: semantic - accepts a multi-line functional block with do-end if it is an ignored method by regex - allows {} if it is a known procedural method - accepts a multi-line functional block with do-end if it is an ignored method - accepts a single line block with {} followed by a safe navigation method call - autocorrects do-end with `rescue` to {} if it is a functional block - accepts a multi-line block with braces when passed to a known functional method - accepts a multi-line block with braces if the return value is assigned - autocorrects do-end with `ensure` to {} if it is a functional block - accepts a multi-line block with braces when passed to a method - autocorrects do-end to {} with appropriate spacing - accepts a single line block with {} if used in a logical or - autocorrects do-end to {} if it is a functional block and does not change the meaning - accepts a single line block with {} if used in an if statement - autocorrects do-end to {} if it is a functional block - accepts a single line block with {} if used in an erange - registers an offense for a multi-line block with do-end if the return value is attribute-assigned - accepts a multi-line block with do-end if it is the return value of its scope - registers an offense for a multi-line block with do-end if the return value is assigned - accepts a single line block with {} if used in an irange - accepts a single line block with {} if used in an array - accepts a single line block with {} if used in a logical and - accepts a multi-line block with braces if it is the return value of its scope - registers an offense for a multi-line block with braces if the return value is not used - accepts a multi-line functional block with do-end if it is a known procedural method - allows {} if it is a known functional method - registers an offense for a multi-line block with do-end if the return value is passed to a method - accepts a multi-line block with braces when chained - with a procedural multi-line block - autocorrects { and } to do and end - autocorrects { and } to do and end with appropriate spacing - with a procedural one-line block - with AllowBracesOnProceduralOneLiners false or unset - accepts a single line block with do-end if it is procedural - registers an offense for a single line procedural block - with AllowBracesOnProceduralOneLiners true - accepts a single line procedural block with braces - accepts a single line procedural do-end block - EnforcedStyle: braces_for_chaining - accepts a multi-line functional block with {} if it is an ignored method by regex - accepts a single line block with braces - accepts a multi-line block that needs braces to be valid ruby - registers an offense for multi-line chained do-end blocks - allows do/end inside Hash[] - registers an offense for a single line block with do-end - disallows {} with no chain inside of Hash[] - allows when :[] is chained - autocorrects do-end with `ensure` to {} if it is a functional block - allows chaining to } inside of Hash[] - accepts a multi-line block with do-end - autocorrects do-end with `rescue` to {} if it is a functional block - accepts a multi-line functional block with {} if it is an ignored method - with safe navigation - registers an offense for multi-line chained do-end blocks - when there are braces around a multi-line block - registers an offense when combined with attribute assignment - allows when the block is being chained - allows when the block is being chained with attribute assignment - registers an offense in the simple case - Ruby >= 2.7 - accepts a multi-line numblock that needs braces to be valid ruby - accepts a single line numblock with braces - registers an offense for a single line numblock with do-end - accepts a multi-line numblock with do-end - EnforcedStyle: always_braces - autocorrects do-end with `rescue` to {} if it is a functional block - registers an offense for multi-line chained do-end blocks - accepts a multi-line block that needs braces to be valid ruby - registers an offense for a single line block with do-end - accepts a multi-line functional block with do-end if it is an ignored method by regex - accepts a single line block with braces - registers an offense for a multi-line block with do-end - accepts a multi-line functional block with do-end if it is an ignored method - registers an offense for multi-lined do-end blocks when combined with attribute assignment - does not autocorrect do-end if {} would change the meaning - autocorrects do-end with `ensure` to {} if it is a functional block - when there are braces around a multi-line block - allows in the simple case - allows when combined with attribute assignment - allows when the block is being chained - BracesRequiredMethods - BracesRequiredMethods methods - allows braces - registers an offense with do - other methods - autocorrects { and } to do and end - allows braces - -RuboCop::Cop::Lint::NonLocalExitFromIterator - allows return in define_singleton_method - allows return in define_method - allows return with value - when lambda is inside of block followed by method chain - allows - when block is not followed by method chain - allows - when block is followed by method chain - and has single argument - registers an offense - and has multiple arguments - registers an offense - and has no argument - allows - when block is lambda - allows - when block in middle of nest is followed by method chain - registers offenses - when the return is within a nested method definition - allows return in a class method definition - allows return in an instance method definition - -RuboCop::Cop::Style::NestedParenthesizedCalls - on a permitted method - doesn't register an offense - on a deeply nested argument - doesn't register an offense - on a call with no arguments, nested in a parenthesized one - doesn't register an offense - on an aref, nested in a parenthesized method call - doesn't register an offense - backslash newline in method call - registers an offense - on a non-parenthesized call nested in a parenthesized one - with multiple arguments to the nested call - registers an offense - with a single argument to the nested call + and multiple arguments registers an offense - when using safe navigation operator - registers an offense - on a call to a setter method - doesn't register an offense - on a nested, parenthesized method call - doesn't register an offense - on a method call with no arguments - doesn't register an offense - on a non-parenthesized method call - doesn't register an offense - -RuboCop::Cop::Style::SymbolArray - with non-default MinSize - does not autocorrect array of one symbol if MinSize > 1 - when EnforcedStyle is percent - registers an offense for arrays of symbols - registers an offense in a non-ambiguous block context - autocorrects arrays of one symbol - doesn't break when a symbol contains ) - does not register an offense if symbol contains whitespace - detects right value for MinSize to use for --auto-gen-config - uses %I when appropriate - autocorrects arrays of symbols with new line - does not register an offense for array with non-syms - does not register an offense for array starting with %i - detects when the cop must be disabled to avoid offenses - autocorrects arrays of symbols with embedded newlines and tabs - when PreferredDelimiters is specified - autocorrects an array with delimiters - autocorrects an array using partial newlines - autocorrects an array in multiple lines - when EnforcedStyle is brackets - autocorrects multiline %i array - does not register an offense for arrays of symbols - autocorrects an array starting with %i - registers an offense for array starting with %i - autocorrects an array has interpolations - registers an offense for empty array starting with %i RuboCop::Cop::Style::OneLineConditional when AlwaysCorrectToMultiline is true + registers and corrects an offense with multi-line construct for if-then-elsif-then-elsif-then-else-end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains method calls with parenthesized arguments registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for unless/then/else/end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains method calls with unparenthesized arguments + registers and corrects an offense with multi-line construct for if/then/else/end when `then` without body registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if-then-elsif-then-else-end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for unless/then/else/end with empty else registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if/then/else/end when `then` without body registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator @@ -21918,4457 +14963,2727 @@ registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if-then-elsif-then-elsif-then-else-end + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains unparenthesized operator method calls registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for unless/then/end - does not register an offense for if/then/end - registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `next` keyword - registers and corrects an offense with multi-line construct for if/then/else/end + does not register an offense for unless/then/else/end with empty else registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator + does not register an offense for if/then/else/end with empty else registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains unparenthesized operator method calls + does not register an offense for unless/then/end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains method calls with unparenthesized arguments + registers and corrects an offense with multi-line construct for unless/then/else/end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end that contains method calls with parenthesized arguments registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `next` keyword registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for if/then/else/end with empty else + registers and corrects an offense with multi-line construct for if-then-elsif-then-else-end + registers and corrects an offense with multi-line construct for if/then/else/end registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with multi-line construct without adding parentheses when if/then/else/end is preceded by an operator - behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a or b` constructs inside inner branches + does not register an offense for if/then/end behaves like if/then/else/end with keyword - registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `raise` keyword - behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a and b` constructs inside inner branches - when IndentationWidth differs from default - registers and corrects an offense with multi-line construct for if/then/else/end + registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `retry` keyword behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `defined? :A` constructs inside inner branches behaves like if/then/else/end with keyword - registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `retry` keyword - behaves like if/then/else/end with keyword registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `break` keyword + when IndentationWidth differs from default + registers and corrects an offense with multi-line construct for if/then/else/end + behaves like if/then/else/end with constructs changing precedence + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a = b` constructs inside inner branches behaves like if/then/else/end with keyword registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `self` keyword behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a ? b : c` constructs inside inner branches + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a and b` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `yield a` constructs inside inner branches + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a ? b : c` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a = b` constructs inside inner branches + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `not a` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `puts 1` constructs inside inner branches + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `a or b` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `super b` constructs inside inner branches + behaves like if/then/else/end with keyword + registers and corrects an offense with multi-line construct when one of the branches of if/then/else/end contains `raise` keyword behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `not a` constructs inside inner branches + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `yield a` constructs inside inner branches + behaves like if/then/else/end with constructs changing precedence + registers and corrects an offense with multi-line construct without adding parentheses for if/then/else/end with `puts 1` constructs inside inner branches when AlwaysCorrectToMultiline is false + registers and corrects an offense with ternary operator and adding parentheses for if/then/else/end that contains method calls with unparenthesized arguments registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if-then-elsif-then-elsif-then-else-end - registers and corrects an offense with ternary operator without adding parentheses for if/then/else/end that contains method calls with parenthesized arguments + registers and corrects an offense with ternary operator for if/then/else/end when `then` without body registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for if/then/end - registers and corrects an offense with ternary operator for unless/then/else/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with ternary operator and adding parentheses for if/then/else/end that contains method calls with unparenthesized arguments - does not register an offense for if/then/else/end with empty else registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + does not register an offense for if/then/else/end with empty else registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if-then-elsif-then-end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for unless/then/else/end with empty else - registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `next` keyword registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with multi-line construct for if-then-elsif-then-else-end - registers and corrects an offense with ternary operator for if/then/else/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - does not register an offense for unless/then/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with ternary operator without adding parentheses for if/then/else/end that contains unparenthesized operator method calls + registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `next` keyword registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with ternary operator for if/then/else/end when `then` without body registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct for if-then-elsif-then-elsif-then-else-end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct for if-then-elsif-then-end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + does not register an offense for unless/then/else/end with empty else registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with multi-line construct for if-then-elsif-then-else-end + registers and corrects an offense with ternary operator for unless/then/else/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + does not register an offense for if/then/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + does not register an offense for unless/then/end registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator + registers and corrects an offense with ternary operator for if/then/else/end + registers and corrects an offense with ternary operator without adding parentheses for if/then/else/end that contains method calls with parenthesized arguments registers and corrects an offense with ternary operator and adding parentheses when if/then/else/end is preceded by an operator - registers and corrects an offense with ternary operator without adding parentheses for if/then/else/end that contains unparenthesized operator method calls behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `puts 1` constructs inside inner branches + registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `super b` constructs inside inner branches + behaves like if/then/else/end with constructs changing precedence + registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a ? b : c` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `defined? :A` constructs inside inner branches - behaves like if/then/else/end with keyword - registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `break` keyword - behaves like if/then/else/end with keyword - registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `retry` keyword behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a and b` constructs inside inner branches + behaves like if/then/else/end with keyword + registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `raise` keyword + behaves like if/then/else/end with keyword + registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `break` keyword behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `not a` constructs inside inner branches + registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `puts 1` constructs inside inner branches behaves like if/then/else/end with keyword registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `self` keyword - behaves like if/then/else/end with keyword - registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `raise` keyword + behaves like if/then/else/end with constructs changing precedence + registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `not a` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a = b` constructs inside inner branches behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a ? b : c` constructs inside inner branches + registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a or b` constructs inside inner branches + behaves like if/then/else/end with keyword + registers and corrects an offense with ternary operator when one of the branches of if/then/else/end contains `retry` keyword behaves like if/then/else/end with constructs changing precedence registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `yield a` constructs inside inner branches - behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `super b` constructs inside inner branches - behaves like if/then/else/end with constructs changing precedence - registers and corrects an offense with ternary operator and adding parentheses inside for if/then/else/end with `a or b` constructs inside inner branches - -RuboCop::Cop::Style::CommentedKeyword - registers an offense and corrects when commenting on the same line as `module` - does not register an offense if there are no comments after keywords - registers an offense and corrects when commenting on the same line as `class` - checks a long comment in less than one second - registers an offense and corrects when commenting on indented keywords - registers an offense and corrects when commenting after keyword with spaces - registers an offense and corrects for one-line cases - does not register an offense if AST contains # symbol - registers an offense and corrects when commenting on the same line as `def` - does not register an offense for certain comments - registers an offense and corrects when commenting on the same line as `begin` - registers an offense and corrects when commenting on the same line as `end` - accepts keyword letter sequences that are not keywords -RuboCop::Cop::Lint::NestedMethodDefinition - does not register offense for nested definition inside ::Class.new - does not register offense for nested definition inside module_eval - does not register offense for nested definition inside ::Module.new - registers an offense for a nested class method definition - registers an offense for a nested singleton method definition - does not register offense for nested definition inside instance_exec - does not register offense for nested definition inside Struct.new - does not register offense for nested definition inside ::Struct.new - does not register offense for definition of method on local var - registers an offense for a nested method definition inside lambda - does not register offense for nested definition inside instance_eval - does not register offense for nested definition inside class_eval - does not register offense for nested definition inside Class.new - does not register offense for nested definition inside class shovel - does not register offense for nested definition inside Module.new - does not register an offense for a lambda definition inside method - registers an offense for a nested method definition - does not register offense for nested definition inside class_exec - does not register offense for nested definition inside module_exec - when `AllowedMethods: [has_many]` - registers offense for nested definition inside `denied_method` - does not register offense for nested definition inside `has_many` - when `AllowedPatterns: [baz]` - registers offense for nested definition inside `do_qux` - does not register offense for nested definition inside `do_baz` - -RuboCop::Cop::Style::Proc - accepts the Proc.new call without block - accepts the ::Proc.new call without block - registers an offense for ::Proc.new - registers an offense for a Proc.new call - Ruby 2.7 - registers an offense for a Proc.new call - -RuboCop::Cop::Layout::BlockAlignment - accepts end aligned with a call chain left hand side - registers an offense for mismatched block end with an or-asgn (||=) - accepts end aligned with a global variable - accepts end aligned with a variable - registers an offense for mismatched block end with a method call - accepts a block end that does not begin its line - registers an offense for mismatched block end with an op-asgn (+=, -=) - accepts end aligned with an and-asgn (&&=) - accepts end aligned with a method call with arguments - registers an offense for mismatched block end with a variable - registers an offense for mismatched end with a method call with arguments - registers an offense for mismatched block end with a mass assignment - accepts end aligned with an or-asgn (||=) - accepts end aligned with the block when the block is a method argument - does not raise an error for nested block in a method call - registers an offense for mismatched block end with a global variable - registers an offense for mismatched end not aligned with the block that is an argument - accepts end aligned with a mass assignment - registers an offense for mismatched block end with a constant - registers an offense for mismatched block end with a class variable - accepts end aligned with an instance variable - accepts end aligned with a method call - accepts end aligned with a class variable - accepts end aligned with a constant - registers an offense for mismatched block end with an instance variable - accepts end aligned with an op-asgn (+=, -=) - registers an offense for mismatched block end with an and-asgn (&&=) - on a bit-flipped method call - registers an offense and corrects misaligned end brace - aligns end with the ~ operator - when the block has arguments - registers an offense for mismatched block end - on a logically negated method call - aligns end with the ! operator - registers an offense and corrects - when configured to align with start_of_line - errors when do aligned - allows when start_of_line aligned - when variables of a mass assignment spans several lines - registers an offense for end aligned with the block - accepts end aligned with the variables - when the method part is a call chain that spans several lines - registers offenses for misaligned ends - accepts pretty alignment style - accepts two kinds of end alignment - accepts end indented as the start of the block - on an arithmetically negated method call +RuboCop::Cop::Layout::SpaceBeforeSemicolon + registers an offense and corrects space before semicolon + registers an offense and corrects more than one space before a semicolon + does not register an offense for no space before semicolons + inside block braces + when EnforcedStyle for SpaceInsideBlockBraces is no_space + registers an offense and corrects a space between an opening brace and a semicolon + behaves like common behavior + accepts no space between an opening brace and a semicolon + when EnforcedStyle for SpaceInsideBlockBraces is space + accepts a space between an opening brace and a semicolon + behaves like common behavior + accepts no space between an opening brace and a semicolon + heredocs registers an offense and corrects - aligns end with the - operator - when the block is a logical operand - accepts a correctly aligned block end - when configured to align with do - allows when do aligned - errors when start_of_line aligned - when the block is terminated by } - mentions } (not end) in the message - Ruby 2.7 - accepts end aligned with a call chain left hand side - registers an offense for mismatched block end with a mass assignment - when the block has no arguments - registers an offense for mismatched block end - when the block is defined on the next line - registers an offenses for mismatched end alignment - accepts end aligned with the block expression - on a splatted method call - registers an offense and corrects misaligned end braces - aligns end with the splat operator - and the block is an operand - accepts end aligned with a variable - when multiple similar-looking blocks have misaligned ends - registers an offense for each of them - when there is an assignment chain - registers an offense for an end aligned with the 2nd variable - accepts end aligned with the first variable - -RuboCop::Cop::Style::MinMax - with an array literal containing calls to `#min` and `#max` - when the expression is used as a return value - does not register an offense if there are additional elements - does not register an offense if the receivers do not match - registers an offense if the receivers match - does not register an offense if the receiver is implicit - when the expression stands alone - registers an offense if the receivers match - does not register an offense if the receiver is implicit - does not register an offense if the receivers do not match - does not register an offense if there are additional elements - when the expression is used in a parallel assignment - does not register an offense if the receiver is implicit - does not register an offense if there are additional elements - registers an offense if the receivers match - does not register an offense if the receivers do not match - -RuboCop::Cop::Style::MethodCallWithoutArgsParentheses - accepts parens after not - autocorrects calls that could be empty literals - registers an offense for `obj.method += func()` - accepts parens in method call with args - accepts special lambda call syntax - registers an offense for parens in method call without args - registers an offense for `obj.method ||= func()` - accepts parentheses for methods starting with an upcase letter - registers an offense for `obj.method &&= func()` - assignment to a variable with the same name - accepts parens in local variable assignment - accepts parens in shorthand assignment - accepts parens in complex assignment - accepts parens in default argument assignment - accepts parens in parallel assignment - when AllowedPatterns is enabled - ignores method listed in AllowedMethods - when AllowedMethods is enabled - ignores method listed in AllowedMethods - method call as argument - registers an offense with empty parens - accepts without parens - registers an empty parens offense for multiple assignment - -RuboCop::Cop::Lint::OutOfRangeRegexpRef - registers an offense when the regexp is matched with `match` - registers an offense when references are used before any regexp - does not register offense to a regexp with valid references for named captures - does not register offense to a regexp with encoding option and valid references for numbered captures - registers an offense when out of range references are used for numbered captures - ignores calls to `match?` - ignores `match` with no receiver - does not register offense to a regexp with valid references for a mix named and numbered captures - registers an offense when the regexp is matched with `===` - registers an offense when out of range references are used inside a when clause - ignores `match` with no arguments - uses the maximum number of captures for when clauses with multiple conditions - registers an offense when out of range references are used for mix of numbered and named captures - registers an offense when the regexp appears on the right hand side of `=~` - does not register offense to a regexp with valid references for numbered captures - does not register an offense regexp containing non literal - does not register an offense when in range references are used inside a when clause - only registers an offense for when clauses when the regexp is matched as a literal - ignores regexp when clause conditions that contain interpolations - registers an offense when out of range references are used for non captures - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used for named captures - matching with partition - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - matching with sub! - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - matching with match - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - matching with `[]` - does not register an offense when in range references are used - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - matching with sub - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - does not register an offense when in range references are used - matching with slice - registers an offense when out of range references are used - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - matching with start_with? - registers an offense when out of range references are used - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - matching with scan - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - does not register an offense when in range references are used - when calling a regexp method on a nth-ref node - registers an offense if the capturing groups have changed - does not register an offense when calling gsub on a valid nth-ref - registers an offense when calling gsub on an invalid nth-ref - matching with `grep` - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - matching with gsub - does not register an offense when in range references are used - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - matching with rindex - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - matching with slice! - does not register an offense when in range references are used - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - matching with end_with? - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - does not register an offense when in range references are used - matching with index - does not register an offense when in range references are used - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - when both the LHS and RHS use regexp - only considers the RHS regexp - matching with rpartition - registers an offense when out of range references are used - only registers an offense when the regexp is matched as a literal - does not register an offense when in range references are used - matching with gsub! - only registers an offense when the regexp is matched as a literal - registers an offense when out of range references are used - does not register an offense when in range references are used - -RuboCop::Cop::Style::RedundantAssignment - reports an offense for def ending with assignment and returning - accepts empty when nodes - does not register an offense when ensure block present - accepts empty if body - accepts empty method body - when inside a when-branch - registers an offense and autocorrects - when inside begin-end body - registers an offense and autocorrects - when rescue blocks present - registers an offense and autocorrects when inside function or rescue block - when inside an if-branch - registers an offense and autocorrects - -RuboCop::Cop::Lint::FlipFlop - registers an offense for inclusive flip-flops - registers an offense for exclusive flip-flops - -RuboCop::Cop::Style::RedundantSortBy - autocorrects array.sort_by do |x| x end - autocorrects array.sort_by { |y| y } - autocorrects array.sort_by { |x| x } - Ruby 2.7 - autocorrects array.sort_by { |x| x } - -RuboCop::Cop::Layout::AssignmentIndentation - ignores comparison operators - allows assignments that do not start on a newline - allows a properly indented rhs - allows a properly indented rhs with fullwidth characters - registers an offense for multi-lhs - registers an offense for incorrectly indented rhs - registers an offense for incorrectly indented rhs whenmultiple assignment with line breaks on each line - registers an offense for incorrectly indented rhs when multiple assignment - when indentation width is overridden for this cop only - allows a properly indented rhs - autocorrects indentation - -RuboCop::Cop::Lint::Void - registers an offense for void op + if not on last line - accepts percent-x commands - accepts void op % by itself without a begin block - accepts void op > by itself without a begin block - registers an offense for void var @var if not on last line - accepts void unary op ! by itself without a begin block - registers an offense for void var @@var if not on last line - registers an offense for void op % if not on last line - registers an offense for void op >= if not on last line - registers two offenses for void literals in `#tap` method - accepts void op / by itself without a begin block - registers two offenses for void literals in a setter method - accepts void op - by itself without a begin block - registers an offense for void unary op ~ if not on last line - registers an offense for void var $var if not on last line - registers an offense for void sign op - if not on last line - accepts void op * by itself without a begin block - registers an offense for void op == if not on last line - accepts void op === by itself without a begin block - registers an offense for void lit :test if not on last line - handles explicit begin blocks - registers two offenses for void literals in a `for` - accepts void op != if on last line - registers an offense for void op * if not on last line - registers an offense for void lit {} if not on last line - accepts void unary op + by itself without a begin block - registers an offense for void op / if not on last line - registers an offense for void lit 2.0 if not on last line - accepts void unary op - by itself without a begin block - registers an offense for void sign op + if not on last line - registers an offense for void var VAR if not on last line - accepts method with erange block - accepts void op == if on last line - accepts short call syntax - registers an offense for void `defined?` if not on last line - registers an offense for void op <= if not on last line - registers an offense for void var var if not on last line - accepts void op % if on last line - registers two offenses for void literals in an initialize method - accepts method with irange block - accepts void op * if on last line - accepts void op + by itself without a begin block - registers an offense for void op != if not on last line - registers an offense for void lit /test/ if not on last line - accepts void op > if on last line - registers an offense for void lit 1 if not on last line - accepts backtick commands - registers an offense for void unary op ! if not on last line - registers an offense for void lit [1] if not on last line - accepts void unary op - if on last line - handles `#each` block with single expression - accepts empty block - accepts void op <= if on last line - registers an offense for void `self` if not on last line - registers an offense for void literal in a method definition - accepts void unary op ~ by itself without a begin block - accepts void op <= by itself without a begin block - accepts void op >= by itself without a begin block - accepts void unary op ~ if on last line - accepts void op == by itself without a begin block - accepts void op <=> by itself without a begin block - registers an offense for void op <=> if not on last line - accepts void op / if on last line - registers an offense for void op === if not on last line - accepts void op - if on last line - accepts void op <=> if on last line - registers two offenses for void literals in a `#each` method - registers an offense for void op < if not on last line - accepts void op >= if on last line - registers an offense for void op - if not on last line - accepts void op < by itself without a begin block - accepts void op != by itself without a begin block - accepts void unary op ! if on last line - accepts void op === if on last line - accepts void unary op + if on last line - registers an offense for void op > if not on last line - accepts void op < if on last line - accepts void op + if on last line - when checking for methods with no side effects - registers an offense for chained methods - registers an offense if not on last line - Ruby 2.7 - registers two offenses for void literals in `#tap` method - when not checking for methods with no side effects - does not register an offense for void nonmutating methods -RuboCop::Cop::Naming::RescuedExceptionsVariableName - with the `PreferredName` setup - registers an offense when using `_e` - does not register an offense when using `_exception` - registers an offense when using `e` - does not register an offense when using `exception` - registers offenses when using `foo` and `bar` in multiple rescues - with default config - when the variable is reassigned - only corrects uses of the exception - only corrects the exception variable - with implicit rescue - without `Exception` variable +RuboCop::Cop::Lint::UnifiedInteger + target ruby version >= 2.4 + when Fixnum + without any decorations + registers an offense + when explicitly specified as toplevel constant + registers an offense + with MyNamespace does not register an offense - with `Exception` variable - registers an offense when using `_exc` - does not register an offense when using `_e` - does not register an offense when using `e` - registers an offense when using `exc` - with explicit rescue - with `Exception` variable - registers an offense when using `exc` - registers offenses when using `foo` and `bar` in multiple rescues - registers an offense when using `exc` and renames its usage - does not register an offense when using _e followed by e - does not register an offense when using `_e` - does not register an offense when using `e` - registers an offense when using `_exc` - with splat operator as `Exception` list - registers an offense with unexpected variable name - does not register an offense with expected variable name - does not register an offense without variable name - without `Exception` variable + target ruby version < 2.4 + when Fixnum + without any decorations + registers an offense and autocorrects + with MyNamespace does not register an offense - shadowing an external variable + when explicitly specified as toplevel constant + registers an offense + target ruby version < 2.4 + when Bignum + without any decorations + registers an offense and autocorrects + when explicitly specified as toplevel constant + registers an offense + with MyNamespace does not register an offense - with lower letters class name + target ruby version >= 2.4 + when Bignum + when explicitly specified as toplevel constant + registers an offense + without any decorations + registers an offense + with MyNamespace does not register an offense - with method as `Exception` - does not register an offense without variable name - registers an offense with unexpected variable name - does not register an offense with expected variable name - with variable being referenced - renames the variable references when autocorrecting - when the variable is reassigned using multiple assignment - only corrects uses of the exception - with nested rescues - handles it - with multiple branches - registers and corrects each offense - -RuboCop::Cop::Commissioner - #investigate - traverses the AST and invoke cops specific callbacks - stores all errors raised by the cops - when given a source with parsing errors - only calls on_other_file - when passed :raise_cop_error option - re-raises the exception received while processing - when passed :raise_error option - re-raises the exception received while processing - traverses the AST with on_send / on_csend - for a restricted cop - calls on_send for the right method calls - on both csend and send - calls on_send for the right method calls - for unrestricted cops - calls on_send all method calls - when given a force - passes the input params to all cops/forces that implement their own #investigate method - when a cop reports offenses - returns all offenses found by the cops - -RuboCop::Cop::Lint::RandOne - behaves like offenses - Kernel.rand(-1) - registers an offense - behaves like no offense - rand(-1..1) - does not register an offense - behaves like no offense - rand(2) - does not register an offense - behaves like offenses - rand 1 - registers an offense - behaves like offenses - Kernel.rand(1) - registers an offense - behaves like no offense - ::Kernel.rand - does not register an offense - behaves like no offense - Kernel.rand 2 - does not register an offense - behaves like offenses - Kernel.rand(-1.0) - registers an offense - behaves like no offense - Kernel.rand(-1..1) + when Integer + without any decorations does not register an offense - behaves like offenses - Kernel.rand 1.0 - registers an offense - behaves like no offense - Kernel.rand + when explicitly specified as toplevel constant does not register an offense - behaves like no offense - rand + with MyNamespace does not register an offense - behaves like offenses - rand(-1) - registers an offense - behaves like offenses - ::Kernel.rand(1) - registers an offense - behaves like offenses - rand(-1.0) - registers an offense - behaves like offenses - rand(1.0) - registers an offense - -RuboCop::Cop::Security::Eval - accepts eval with no arguments - registers an offense for eval with string that has an interpolation - accepts eval with a string that interpolates a literal - accepts eval as method - accepts eval as variable - registers an offense for eval as command - registers an offense for eval as function - registers an offense `Binding#eval` - accepts eval with a multiline string - accepts eval on a literal string - with an explicit binding, filename, and line number - registers an offense for eval as function - registers an offense for eval as command - accepts eval on a literal string -RuboCop::Cop::Style::SafeNavigation - allows calls using safe navigation - allows a method call as a parameter when the parameter is safe guarded with an object check - allows a method call safeguarded with a negative check for the object when using `if` - allows calls to methods not safeguarded by respond_to - allows an object check before hash access - allows an object check before a method call that is used in a regex comparison - allows method call that is used in a negated regex comparison safe guarded by an object check - allows calls on nil - allows an object check before a method call that is used with `empty?` - allows an object check before a method call that is used in a comparison - allows for empty if blocks with comments - allows an object check before a negated predicate - allows method call that is used in a spaceship comparison safe guarded by an object check - allows method call that is used in a comparison safe guarded by an object check - allows a method call safeguarded when using `unless nil?` - allows an object check before a negated predicate method chain - allows an object check before a negated method call with a safe navigation - allows an object check before a long chain with a block - allows an object check before a blank check - allows a method chain that is used in a comparison safe guarded by an object check - allows an object check before a method call that is used in a negated regex comparison - allows method call that is used in a regex comparison safe guarded by an object check - allows an object check before a method chain that is used in a comparison - allows a method call safeguarded with a negative check for the object when using `unless` - allows an object check before a nil check on a short chain - allows object checks in the condition of an elsif statement and a method call on that object in the body - allows chained method calls during assignment safe guardedby an object check - allows an object check before a method chain longer than 2 methods - allows an object check before a nil check on a long chain - allows an object check before a method call that is used in a spaceship comparison - allows method calls that do not get called using . safe guarded by an object check - allows chained method calls during arithmetic operations safe guarded by an object check - does not move comments that are inside an inner block - behaves like all variable types - if expression - registers an offense for a single method call inside of a non-nil check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call with params inside of a check for the object - registers an offense for a single method call inside of a check for the object - does not lose comments within if expression - only moves comments that fall within the expression - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call inside of an unless negative check for the object - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a check for the object - registers an offense for a single method call with params inside of a non-nil check for the object - registers an offense for a single method call with params inside of an unless nil check for the object - allows a single method call inside of a check for the object with an else - registers an offense for a single method call with params and a block inside of a non-nil check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - registers an offense for a single method call inside of an unless nil check for the object - registers an offense for a single method call with a block inside of a non-nil check for the object - ternary expression - allows ternary expression - modifier if - registers an offense for a method call with params safeguarded with a nil check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense for a method call safeguarded with a nil check for the object - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a chained method call safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense for a chained method call safeguarded with a check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - object check before method call - allows a nil object check followed by a method call with a block - allows a non object check followed by a method call with params and a block - allows a nil object check followed by a method call - allows a non object check followed by a method call - allows a non object check followed by a method call with a block - allows a nil object check followed by a method call with params - allows a nil object check followed by a method call with params and a block - allows a non object check followed by a method call with params - ConvertCodeThatCanStartToReturnNil true - registers an offense for a non-nil object check followed by a method call - registers an offense for a non-nil object check followed by a method call with params - corrects an object check followed by a method call and another check - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - registers an offense for an object check followed by a method call with a block - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method call with params and a block - method chaining - registers an offense for an object check followed by chained method calls with blocks - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls - allows an object check followed by chained method calls with blocks - MaxChainLength: 1 - registers an offense for an object check followed by 1 chained method calls - allows an object check followed by 2 chained method calls - MaxChainLength: 3 - allows an object check followed by 4 chained method calls - registers an offense for an object check followed by 3 chained method calls - ConvertCodeThatCanStartToReturnNil false - allows a non-nil object check followed by a method call with params - allows a non-nil object check followed by a method call with a block - allows a non-nil object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - registers an offense for an object check followed by a method call with params and a block - registers an offense for an object check followed by a method call with a block - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method calls that nil responds to - allows a non-nil object check followed by a method call - registers an offense for an object check followed by a method call with params - method chaining - corrects an object check followed by a chained method call - corrects an object check followed by a chained method call with a block - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call with params - behaves like all variable types - if expression - registers an offense for a single method call with params and a block inside of a non-nil check for the object - registers an offense for a single method call with params inside of a non-nil check for the object - only moves comments that fall within the expression - registers an offense for a single method call with params inside of a check for the object - registers an offense for a single method call inside of a check for the object - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a non-nil check for the object - registers an offense for a single method call inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - allows a single method call inside of a check for the object with an else - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call inside of an unless negative check for the object - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a check for the object - registers an offense for a single method call inside of a non-nil check for the object - does not lose comments within if expression - registers an offense for a single method call with params inside of an unless nil check for the object - ternary expression - allows ternary expression - modifier if - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call safeguarded with a nil check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense for a method call with params safeguarded with a nil check for the object - registers an offense for a chained method call safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - registers an offense for a chained method call safeguarded with a check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - object check before method call - allows a nil object check followed by a method call - allows a nil object check followed by a method call with a block - allows a nil object check followed by a method call with params - allows a non object check followed by a method call with a block - allows a nil object check followed by a method call with params and a block - allows a non object check followed by a method call with params and a block - allows a non object check followed by a method call - allows a non object check followed by a method call with params - ConvertCodeThatCanStartToReturnNil true - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - corrects an object check followed by a method call and another check - registers an offense for an object check followed by a method call - registers an offense for a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method call with params and a block - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call - method chaining - registers an offense for an object check followed by chained method calls with blocks - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls with blocks - allows an object check followed by chained method calls - MaxChainLength: 3 - registers an offense for an object check followed by 3 chained method calls - allows an object check followed by 4 chained method calls - MaxChainLength: 1 - registers an offense for an object check followed by 1 chained method calls - allows an object check followed by 2 chained method calls - ConvertCodeThatCanStartToReturnNil false - allows a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method calls that nil responds to - registers an offense for an object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method call with a block - allows a non-nil object check followed by a method call - allows a non-nil object check followed by a method call with a block - allows a non-nil object check followed by a method call with params and a block - method chaining - corrects an object check followed by a chained method call with params - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call - corrects an object check followed by a chained method call with a block - behaves like all variable types - object check before method call - allows a nil object check followed by a method call with params and a block - allows a nil object check followed by a method call with a block - allows a nil object check followed by a method call - allows a non object check followed by a method call with params and a block - allows a non object check followed by a method call with a block - allows a nil object check followed by a method call with params - allows a non object check followed by a method call with params - allows a non object check followed by a method call - ConvertCodeThatCanStartToReturnNil false - allows a non-nil object check followed by a method call with params and a block - allows a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method calls that nil responds to - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - allows a non-nil object check followed by a method call - allows a non-nil object check followed by a method call with a block - registers an offense for an object check followed by a method call with a block - method chaining - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call with params - corrects an object check followed by a chained method call - corrects an object check followed by a chained method call with a block - ConvertCodeThatCanStartToReturnNil true - registers an offense for an object check followed by a method call with params and a block - registers an offense for an object check followed by a method call - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for an object check followed by a method call with params - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for a non-nil object check followed by a method call - registers an offense for a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method call with a block - corrects an object check followed by a method call and another check - registers an offense for a check for the object followed by a method call in the condition for an if expression - method chaining - registers an offense for an object check followed by chained method calls with blocks - MaxChainLength: 1 - registers an offense for an object check followed by 1 chained method calls - allows an object check followed by 2 chained method calls - MaxChainLength: 3 - allows an object check followed by 4 chained method calls - registers an offense for an object check followed by 3 chained method calls - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls with blocks - allows an object check followed by chained method calls - modifier if - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a chained method call safeguarded with a check for the object - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call with params safeguarded with a nil check for the object - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for a chained method call safeguarded with a negative nil check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a method call safeguarded with a nil check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check - if expression - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call inside of a non-nil check for the object - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a non-nil check for the object - registers an offense for a single method call inside of an unless nil check for the object - registers an offense for a single method call with params inside of a non-nil check for the object - registers an offense for a single method call with params and a block inside of a non-nil check for the object - allows a single method call inside of a check for the object with an else - does not lose comments within if expression - registers an offense for a single method call inside of a check for the object - only moves comments that fall within the expression - registers an offense for a single method call with params inside of a check for the object - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call with params inside of an unless nil check for the object - registers an offense for a single method call with a block inside of a check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - ternary expression - allows ternary expression - when Ruby <= 2.2 - does not register an offense when a method call that nil responds to safe guarded by an object check - behaves like all variable types - object check before method call - allows a non object check followed by a method call with a block - allows a nil object check followed by a method call with params and a block - allows a non object check followed by a method call with params and a block - allows a nil object check followed by a method call - allows a non object check followed by a method call - allows a nil object check followed by a method call with params - allows a non object check followed by a method call with params - allows a nil object check followed by a method call with a block - ConvertCodeThatCanStartToReturnNil false - registers an offense for an object check followed by a method call with params and a block - allows a non-nil object check followed by a method call with params - allows a non-nil object check followed by a method call with a block - registers an offense for an object check followed by a method call with a block - allows a non-nil object check followed by a method call - registers an offense for a check for the object followed by a method call in the condition for an if expression - registers an offense for an object check followed by a method calls that nil responds to - registers an offense for an object check followed by a method call with params - allows a non-nil object check followed by a method call with params and a block - registers an offense for an object check followed by a method call - method chaining - corrects an object check followed by a chained method call with a block - corrects an object check followed by a chained method call with params - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call - ConvertCodeThatCanStartToReturnNil true - registers an offense for a non-nil object check followed by a method call - registers an offense for a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - corrects an object check followed by a method call and another check - registers an offense for an object check followed by a method call with params - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for an object check followed by a method call with a block - method chaining - registers an offense for an object check followed by chained method calls with blocks - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls with blocks - allows an object check followed by chained method calls - MaxChainLength: 1 - allows an object check followed by 2 chained method calls - registers an offense for an object check followed by 1 chained method calls - MaxChainLength: 3 - registers an offense for an object check followed by 3 chained method calls - allows an object check followed by 4 chained method calls - if expression - registers an offense for a single method call inside of a check for the object - allows a single method call inside of a check for the object with an else - registers an offense for a single method call with a block inside of a non-nil check for the object - registers an offense for a single method call with params inside of a non-nil check for the object - registers an offense for a single method call inside of an unless negative check for the object - only moves comments that fall within the expression - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call with params inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - does not lose comments within if expression - registers an offense for a single method call inside of a non-nil check for the object - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of a non-nil check for the object - registers an offense for a single method call with params inside of a check for the object - registers an offense for a single method call with a block inside of a check for the object - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - ternary expression - allows ternary expression - modifier if - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call safeguarded with a nil check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a chained method call safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for a chained method call safeguarded with a check for the object - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense for a method call with params safeguarded with a nil check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like all variable types - modifier if - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a method call safeguarded with a nil check for the object - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call with params safeguarded with a nil check for the object - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a chained method call safeguarded with a negative nil check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a chained method call safeguarded with a check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - object check before method call - allows a nil object check followed by a method call - allows a nil object check followed by a method call with a block - allows a non object check followed by a method call with params - allows a nil object check followed by a method call with params and a block - allows a nil object check followed by a method call with params - allows a non object check followed by a method call with a block - allows a non object check followed by a method call - allows a non object check followed by a method call with params and a block - ConvertCodeThatCanStartToReturnNil true - registers an offense for an object check followed by a method call with params and a block - registers an offense for a non-nil object check followed by a method call with params - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for an object check followed by a method call with params - corrects an object check followed by a method call and another check - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call - registers an offense for a check for the object followed by a method call in the condition for an if expression - method chaining - registers an offense for an object check followed by chained method calls with blocks - MaxChainLength: 1 - allows an object check followed by 2 chained method calls - registers an offense for an object check followed by 1 chained method calls - MaxChainLength: 3 - registers an offense for an object check followed by 3 chained method calls - allows an object check followed by 4 chained method calls - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls - allows an object check followed by chained method calls with blocks - ConvertCodeThatCanStartToReturnNil false - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call with a block - registers an offense for an object check followed by a method call - allows a non-nil object check followed by a method call with params - allows a non-nil object check followed by a method call - allows a non-nil object check followed by a method call with a block - registers an offense for an object check followed by a method call with params and a block - registers an offense for an object check followed by a method calls that nil responds to - registers an offense for a check for the object followed by a method call in the condition for an if expression - allows a non-nil object check followed by a method call with params and a block - method chaining - corrects an object check followed by a chained method call - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call with params - corrects an object check followed by a chained method call with a block - if expression - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call inside of a non-nil check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a non-nil check for the object - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call with a block inside of a check for the object - allows a single method call inside of a check for the object with an else - registers an offense for a single method call with params inside of a non-nil check for the object - registers an offense for a single method call inside of an unless nil check for the object - does not lose comments within if expression - registers an offense for a single method call inside of an unless negative check for the object - registers an offense for a single method call inside of a check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - registers an offense for a single method call with params inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call with params and a block inside of a non-nil check for the object - registers an offense for a single method call with params inside of a check for the object - only moves comments that fall within the expression - ternary expression - allows ternary expression - respond_to? - allows method calls safeguarded by a respond_to check to a different method - allows method calls safeguarded by a respond_to check on adifferent variable but the same method - allows method calls safeguarded by a respond_to check on adifferent variable and method - allows enumerable accessor method calls safeguarded by a respond_to check - allows method calls safeguarded by a respond_to check - behaves like all variable types - if expression - allows a single method call inside of a check for the object with an else - registers an offense for a single method call inside of a non-nil check for the object - registers an offense for a single method call with params inside of a non-nil check for the object - registers an offense for a single method call with params and a block inside of an unless negative check for the object - registers an offense for a single method call with params and a block inside of an unless nil check for the object - registers an offense for a single method call with params inside of an unless nil check for the object - registers an offense for a single method call with params and a block inside of a non-nil check for the object - registers an offense for a single method call inside of a check for the object - registers an offense for a single method call with params inside of a check for the object - registers an offense for a single method call with a block inside of an unless negative check for the object - registers an offense for a single method call inside of an unless negative check for the object - registers an offense for a single method call with a block inside of a non-nil check for the object - registers an offense for a single method call with a block inside of an unless nil check for the object - registers an offense for a single method call inside of an unless nil check for the object - registers an offense for a single method call with params inside of an unless negative check for the object - only moves comments that fall within the expression - does not lose comments within if expression - registers an offense for a single method call with params and a block inside of a check for the object - registers an offense for a single method call with a block inside of a check for the object - ternary expression - allows ternary expression - object check before method call - allows a non object check followed by a method call with params - allows a nil object check followed by a method call with params and a block - allows a non object check followed by a method call with params and a block - allows a non object check followed by a method call with a block - allows a nil object check followed by a method call - allows a nil object check followed by a method call with a block - allows a nil object check followed by a method call with params - allows a non object check followed by a method call - ConvertCodeThatCanStartToReturnNil true - registers an offense for an object check followed by a method call - registers an offense for a non-nil object check followed by a method call with a block - registers an offense for a non-nil object check followed by a method call - registers an offense for a non-nil object check followed by a method call with params and a block - registers an offense for a check for the object followed by a method call in the condition for an if expression - registers an offense for a non-nil object check followed by a method call with params - registers an offense for an object check followed by a method call with params and a block - corrects an object check followed by a method call and another check - registers an offense for an object check followed by a method call with a block - registers an offense for an object check followed by a method call with params - method chaining - registers an offense for an object check followed by chained method calls with blocks - MaxChainLength: 1 - allows an object check followed by 2 chained method calls - registers an offense for an object check followed by 1 chained method calls - MaxChainLength: 3 - allows an object check followed by 4 chained method calls - registers an offense for an object check followed by 3 chained method calls - with Lint/SafeNavigationChain disabled - allows an object check followed by chained method calls with blocks - allows an object check followed by chained method calls - ConvertCodeThatCanStartToReturnNil false - registers an offense for an object check followed by a method call with params - registers an offense for an object check followed by a method call with params and a block - allows a non-nil object check followed by a method call with params - registers an offense for a check for the object followed by a method call in the condition for an if expression - allows a non-nil object check followed by a method call with params and a block - allows a non-nil object check followed by a method call with a block - allows a non-nil object check followed by a method call - registers an offense for an object check followed by a method call - registers an offense for an object check followed by a method calls that nil responds to - registers an offense for an object check followed by a method call with a block - method chaining - corrects an object check followed by a chained method call with a block - corrects an object check followed by a chained method call - corrects an object check followed by a chained method call with a symbol proc - corrects an object check followed by a chained method call with params - modifier if - registers an offense for a chained method call safeguarded with a check for the object - registers an offense for a method call with a block safeguarded with a nil check for the object - registers an offense for a method call with params and a block safeguarded with a check for the object - registers an offense for a chained method call safeguarded with an unless nil check for the object - registers an offense for a method call with params and a block safeguarded with a nil check for the object - registers an offense for a method call on an accessor safeguarded by a check for the accessed variable - registers an offense for a method call with a block safeguarded with a negative nil check for the object - registers an offense for a method call with a block safeguarded with a check for the object - registers an offense for a method call with params and a block safeguarded with a negative nil check for the object - registers an offense for a method call safeguarded with a negative check for the object - registers an offense for a method call with params safeguarded with a negative check for the object - registers an offense for a method call with params safeguarded with a check for the object - registers an offense for an object check followed by a method call with a comment at EOL - registers an offense for a method call with params safeguarded with a negative nil check for the object - registers an offense for a method call with params safeguarded with a nil check for the object - registers an offense for a method call safeguarded with a negative nil check for the object - registers an offense for a method call with params and a block safeguarded with a negative check for the object - registers an offense for a method call safeguarded with a check for the object - registers an offense for a method call safeguarded with a nil check for the object - registers an offense when safe guard check and safe navigation method call are connected with `&&` condition - registers an offense for a method call with a block safeguarded with a negative check for the object - registers an offense for a method call that nil responds to safe guarded by an object check - registers an offense for a chained method call safeguarded with a negative nil check for the object - behaves like safe guarding logical break keywords - allows a method call being passed to fail safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to yield safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to throw safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to next safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to break safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to raise safe guarded by an object check - behaves like safe guarding logical break keywords - allows a method call being passed to return safe guarded by an object check +RuboCop::Cop::InternalAffairs::SingleLineComparison + does not register an offense when comparing the same line + registers and corrects an offense when comparing `loc.line` with `loc.last_line` + registers and corrects an offense when comparing `loc.last_line` with `loc.first_line` + does not register an offense when the receivers are not a match + registers and corrects an offense when negative comparing `first_line` with `last_line` + registers and corrects an offense when comparing `loc.last_line` with `loc.line` + registers and corrects an offense when comparing `last_line` with `first_line` + registers and corrects an offense when comparing `source_range.first_line` with `source_range.last_line` + registers and corrects an offense when negative comparing `last_line` with `first_line` + registers and corrects an offense when comparing `loc.first_line` with `loc.last_line` + registers and corrects an offense when comparing `first_line` with `last_line` + registers and corrects an offense when comparing `source_range.last_line` with `source_range.first_line` -RuboCop::Cop::Layout::AccessModifierIndentation - when EnforcedStyle is set to outdent - accepts private def indented to method depth in singleton class - registers an offense and corrects misaligned access modifiers in nested classes - accepts private def indented to method depth in module defined with Module.new - registers an offense and corrects module_function indented to method depth in a module - accepts module fn def indented to method depth in a module - registers an offense and corrects private indented to method depth in singleton class - accepts private def indented to method depth in a class - registers an offense and corrects private indented to method depth in a module - accepts private def indented to method depth in a module - accepts module fn with argument indented to method depth in a module - registers an offense and corrects private indented to method depth in class defined with Class.new - accepts private indented to the containing class indent level - accepts private with argument indented to method depth in singleton class - accepts private with argument indented to method depth in a module - registers offense and corrects private indented to method depth in a class - accepts private with argument indented to method depth in a class - accepts private with argument indented to method depth in class defined with Class.new - accepts protected indented to the containing class indent level - registers an offense and corrects private indented to method depth in module defined with Module.new - accepts private def indented to method depth in class defined with Class.new - accepts private with argument indented to method depth in module defined with Module.new - when EnforcedStyle is set to indent - registers an offense and corrects misaligned protected - registers an offense and corrects misaligned private in module - accepts an empty class - registers an offense and corrects correct + opposite alignment - accepts properly indented protected - registers an offense and corrects opposite + correct alignment - registers an offense and corrects misaligned private - accepts properly indented private - registers an offense and corrects misaligned access modifiers in nested classes - registers an offense and corrects misaligned private in class defined with Class.new - registers an offense and corrects misaligned private in a singleton class - registers an offense and corrects misaligned private in module defined with Module.new - registers an offense and corrects misaligned module_function in module - accepts methods with a body - accepts indented access modifiers with arguments in nested classes - accepts properly indented private in module defined with Module.new - registers an offense and corrects access modifiers in arbitrary blocks - when 4 spaces per indent level are used - accepts properly indented private - when indentation width is overridden for this cop only - accepts properly indented private +RuboCop::Cop::Style::NumberedParametersLimit + with Ruby >= 2.7 + does not register an offense for a normal block with too many parameters + sets Max properly for auto-gen-config + does not register an offense for a numblock with fewer than `Max` parameters + does not register an offense for a numblock with exactly `Max` parameters + when there are more than `Max` numbered parameters + registers an offense for a single line `numblock` + registers an offense for a multiline `numblock` + when configuring Max + does not register an offense when there are not too many numbered params + when Max is 1 + uses the right offense message -RuboCop::Cop::Layout::SpaceAfterComma - block argument commas without space - behaves like ends with an item - registers an offense and does autocorrection - behaves like trailing comma - accepts the last comma - method call arg commas without space - behaves like ends with an item - registers an offense and does autocorrection - inside hash braces - when EnforcedStyle for SpaceInsideBlockBraces is space - registers an offense for no space between a comma and a closing brace - behaves like common behavior - accepts a space between a comma and a closing brace - when EnforcedStyle for SpaceInsideBlockBraces is no_space - accepts no space between a comma and a closing brace - behaves like common behavior - accepts a space between a comma and a closing brace - array index commas without space - behaves like ends with an item - registers an offense and does autocorrection - behaves like trailing comma - accepts the last comma +RuboCop::Cop::Lint::DeprecatedConstants + registers and corrects an offense when using `NIL` + does not register an offense when not using deprecated constant + registers and corrects an offense when using `::NIL` + registers and corrects an offense when using deprecated methods that have no deprecated version + registers and corrects an offense when using `FALSE` + registers and corrects an offense when using `::Triple::Nested::Constant` + registers and corrects an offense when using `::TRUE` + does not register an offense when using `__ENCODING__ + registers and corrects an offense when using `TRUE` + registers and corrects an offense when using `::FALSE` + registers and corrects an offense when using deprecated methods that have no alternative + Ruby <= 2.7 + does not register an offense when using `Random::DEFAULT` + Ruby <= 2.5 + does not register an offense when using `Net::HTTPServerException` + Ruby >= 2.6 + registers and corrects an offense when using `Net::HTTPServerException` + Ruby >= 3.0 + registers and corrects an offense when using `::Random::DEFAULT` + registers and corrects an offense when using `Random::DEFAULT` -RuboCop::Cop::Util - #to_supported_styles - when EnforcedStyleInsidePipes - is expected to eq "SupportedStylesInsidePipes" - when EnforcedStyle - is expected to eq "SupportedStyles" - #same_line? - returns false when two nodes are not on the same line - returns false if an argument is not a node or range - returns true when two nodes are on the same line - can use ranges - #line_range - returns line range of the expression +RuboCop::Cop::Naming::BlockForwarding + when `EnforcedStyle: anonymous + Ruby < 3.0 + does not register an offense when not using anonymous block forwarding + Ruby >= 3.1 + registers and corrects an offense when using `yield` in method body + does not register an offense when using anonymous block forwarding without method body + does not register an offense when using anonymous block forwarding + does not register an offense when assigning the block arg + does not register an offense when defining kwoptarg with block args method + registers and corrects an offense when using symbol proc argument in method body + does not register an offense when defining no arguments method + registers and corrects an offense when using explicit block forwarding in singleton method + does not register an offense when defining kwarg with block args method + registers and corrects an offense when using explicit block forwarding without method definition parentheses + does not register an offense when defining without block argument method + does not register an offense when using block argument as a variable + registers and corrects an only explicit block forwarding when using multiple proc arguments + registers and corrects an offense when using explicit block forwarding + registers and corrects an offense when using explicit block forwarding without method body + when `EnforcedStyle: explicit + Ruby >= 3.1 + registers and corrects an offense when using `yield` in method body + registers and corrects an offense when using symbol proc argument in method body + registers and corrects an offense when using anonymous block forwarding + registers and corrects an offense when using anonymous block forwarding in singleton method + registers and corrects and corrects an offense when using anonymous block forwarding without method body + does not register an offense when using explicit block forwarding without method body + does not register an offense when assigning the block arg + does not register an offense when using explicit block forwarding + does not register an offense when defining without block argument method + when `BlockForwardingName: proc + registers and corrects an offense when using anonymous block forwarding + when `BlockForwardingName: block` is already in use + registers and no corrects an offense when using anonymous block forwarding -RuboCop::Cop::Style::RedundantArgument - registers an offense and corrects when method called on literals - works with double-quoted strings when configuration is single-quotes - does not register an offense when method called with more than one arguments - does not register an offense when method called with no arguments - does not register an offense when method called with no receiver - does not register an offense when method called with different argument - registers an offense and corrects when method called on variable - registers an offense and corrects when method called without parenthesis on variable - registers an offense and corrects when method called without parenthesis on literals - non-builtin method - does not register an offense with other argument - registers an offense and corrects with configured argument +RuboCop::Cop::Lint::AmbiguousOperatorPrecedence + registers an offense when the entire expression is wrapped in parentheses + does not register an offense when expressions are wrapped in parentheses by precedence + allows an operator with `or` + does not register an offense when expressions are wrapped in parentheses by reverse precedence + registers an offense for expressions containing booleans and operators + registers an offense when an expression with mixed boolean operators has no parens + allows an operator with `and` + does not register an offense when there is only one operator in the expression + corrects a super long expression in precedence order + does not register an offense when boolean expressions are wrapped in parens + registers an offense when an expression with mixed precedence has no parens + does not register an offense when all operators in the expression have the same precedence + corrects a super long expression in reverse precedence order -RuboCop::Cop::Lint::SafeNavigationConsistency - allows safe navigation when different variables are used - allows || without safe navigation - registers an offense but does not correct non dot method calls - registers an offense and corrects using unsafe navigation with both && and || - registers an offense and corrects using unsafe navigation with grouped conditions - registers an offense and corrects using safe navigation on the right of || - registers an offense and corrects using safe navigation inside of separated conditions - registers an offense and corrects using safe navigation in conditions on the right hand side - registers an offense and corrects when there is code before or after the condition - registers an offense and corrects using unsafe navigation and the safe navigation appears in a group - registers and corrects multiple offenses - allows calls to methods that nil responds to - registers an offense and corrects using safe navigation on the left of || - registers an offense and corrects assignment - registers an offense and corrects unsafe navigation that appears before safe navigation - registers an offense and corrects using safe navigation on the right of && - registers an offense and corrects using safe navigation on the left of && - registers a single offense and corrects when safe navigation is used multiple times - allows && without safe navigation +RuboCop::Cop::Style::EvenOdd + converts x % 2 == 1 to #odd? + converts x % 2 == 0 to #even? + converts x % 2 != 1 to #even? + converts 1 % 2 != 1 to even? + converts (x._(y)) % 2 != 1 to even? + converts (x % 2) != 0 to #odd? + accepts x % 2 == 2 + converts (y % 2) != 1 to #even? + accepts x % 3 == 0 + converts x % 2 != 0 to #odd? + accepts x % 3 != 0 + converts (x.y % 2) != 1 to #even? + converts (x(y) % 2) != 1 to #even? + converts complex examples + converts (x._(y) % 2) != 1 to even? + converts (x % 2) == 1 to #odd? + converts x._(y) % 2 != 1 to even? + converts (x % 2) == 0 to #even? -RuboCop::Cop::Style::RedundantSelfAssignmentBranch - does not register an offense when not self-assigning redundant branches - does not register an offense when using `elsif` and self-assigning the value of `then` branch - does not register an offense when using `elsif` and self-assigning the value of `else` branch - registers and corrects an offense when self-assigning redundant else branch and empty else branch - does not register an offense when self-assigning redundant else ternary branch for cvar - registers and corrects an offense when self-assigning redundant if branch - does not register an offense when self-assigning redundant else ternary branch for gvar - does not register an offense when self-assigning redundant else branch and multiline else branch - registers and corrects an offense when self-assigning redundant else branch and empty if branch - registers and corrects an offense when self-assigning redundant else branch - does not register an offense when multi assignment - does not register an offense when lhs is not variable - registers and corrects an offense when self-assigning redundant if ternary branch - does not register an offense when self-assigning redundant else branch and multiline if branch - registers and corrects an offense when self-assigning redundant else ternary branch - does not register an offense when using only if branch - does not register an offense when self-assigning redundant else ternary branch for ivar - does not register an offense when using `elsif` and self-assigning the value of `elsif` branch +RuboCop::Cop::Style::NegatedUnless + does not blow up for ternary ops + does not blow up for empty if condition + does not blow up for empty unless condition + does not blow up on a negated ternary operator + with “postfix” style + registers an offense for postfix + does not register an offense for prefix + with “prefix” style + registers an offense for prefix + does not register an offense for postfix + with “both” style + autocorrects by replacing parenthesized unless not with if + accepts an unless/else with negative condition + accepts an unless where the condition is doubly negated + accepts an unless where only part of the condition is negated + registers an offense for unless with exclamation point condition + registers an offense for unless with "not" condition -RuboCop::Cop::Lint::SafeNavigationChain - >= Ruby 2.7 - registers an offense for ordinary method chain exists after safe navigation method call with a block using numbered parameter - TargetRubyVersion >= 2.3 - accepts usages of safe navigation with `present?` method - accepts usages of safe navigation with || operator - accepts usages of safe navigation with && operator - registers an offense for ordinary method chain exists after safe navigation method call - accepts usages of ordinary method chain - accepts usages of safe navigation with `-@` method - accepts usages of safe navigation with === operator - accepts usages of safe navigation with `in?` method - accepts usages of method chain with safe navigation only with argument - registers an offense for safe navigation on the right-hand side of the `-` - accepts usages of method chain with safe navigation only - accepts usages of safe navigation with == operator - registers an offense for safe navigation with <= operator - registers an offense for safe navigation with []= operator - accepts usages of safe navigation with `+@` method - accepts usages of safe navigation at last only - registers an offense for ordinary method call exists after safe navigation method call - registers an offense for safe navigation on the right-hand side of the `*` - accepts usages of safe navigation at last only with argument - accepts usages of safe navigation with `to_d` method - accepts usages of safe navigation with self assignment method - accepts usages of safe navigation with `blank?` method - registers an offense for safe navigation with > operator - accepts usages of safe navigation with & operator - registers an offense for ordinary method chain exists after safe navigation method call with an argument - accepts usages of safe navigation with | operator - registers an offense for safe navigation with + operator - registers an offense for safe navigation on the right-hand side of the `/` - registers an offense for ordinary method call exists after safe navigation method call with an argument - registers an offense for ordinary method chain exists after safe navigation method call with a block-pass - accepts usages of safe navigation with `try` method - registers an offense for safe navigation with [] operator - registers an offense for safe navigation with >= operator - accepts usages of safe navigation with assignment method - registers an offense for safe navigation on the right-hand side of the `+` - registers an offense for safe navigation with < operator - registers an offense for ordinary method chain exists after safe navigation method call with a block - accepts usages of safe navigation with `nil?` method - accepts usages of ordinary method chain with argument - proper highlighting - when in a begin - when used with a modifier if - when there are methods before - when in a method - when there are methods after +RuboCop::Cop::Layout::LineContinuationLeadingSpace + EnforcedStyle: trailing + puts the offense message in correct position also on indented line + registers offense in the right location when 1st line is not the string + marks the correct range when string is a block method argument + registers an offense when 2nd line has multiple leading spaces + marks the correct range when string is a positional method argument + registers an offense when 2nd line has one leading space + registers offenses when 2nd and 3rd line has leading spaces + interpolated strings + registers no offense for correctly formatted multiline interpolated string + registers an offense for incorrectly formatted multiline interpolated string + registers offenses when 2nd line has leading spaces and 2nd line is interpolated + registers no offense for correctly formatted multiline interpolation + registers offenses when 2nd line has leading spaces and 1st line is interpolated + registers no offense on interpolated string alone + registers no offense on doubly interpolated string alone + EnforcedStyle: leading + registers offense in the right location when 1st line is not the string + marks the correct range when string is a positional method argument + puts the offense message in correct position also on indented line + marks the correct range when string is a block method argument + registers offenses when 1st and 2nd line has trailing spaces + registers an offense when 1st line has multiple trailing spaces + registers an offense when 1st line has one trailing space + interpolated strings + registers no offense on doubly interpolated string alone + registers offenses when 1st line has trailing spaces and 2nd line is interpolated + registers no offense on interpolated string alone + registers an offense for incorrectly formatted multiline interpolated string + registers no offense for correctly formatted multiline interpolated string + registers offenses when 1st line has leading spaces and 1st line is interpolated + registers no offense for correctly formatted multiline interpolation -RuboCop::Cop::Gemspec::RequiredRubyVersion - registers an offense when `required_ruby_version` is not specified - registers an offense when `required_ruby_version` is blank - registers an offense when `required_ruby_version` is an empty array - target ruby version > 2.7 - registers an offense when `required_ruby_version` is specified with >= without a minor version and is lower than `TargetRubyVersion` - does not register an offense when `required_ruby_version` is specified with ~> without a patch version and equals `TargetRubyVersion` - does not register an offense when lowest version of `required_ruby_version` equals `TargetRubyVersion` - does not register an offense when `required_ruby_version` is specified with >= and equals `TargetRubyVersion` - registers an offense when `required_ruby_version` is specified with ~> without a minor version and is lower than `TargetRubyVersion` - does not register an offense when `required_ruby_version` is specified with >= without a patch version and equals `TargetRubyVersion` - does not register an offense when `required_ruby_version` is specified with ~> and equals `TargetRubyVersion` - target ruby version > 2.7 - registers an offense when `required_ruby_version` is specified with >= and is lower than `TargetRubyVersion` - recognizes a Gem::Requirement with multiple requirements and does not register an offense - recognizes Gem::Requirement and registers offense - registers an offense when `required_ruby_version` is specified with ~> and is lower than `TargetRubyVersion` - registers an offense when `required_ruby_version` is specified in array and is lower than `TargetRubyVersion` - false negatives - does not register an offense when `required_ruby_version` is assigned as a variable (string literal) - does not register an offense when `required_ruby_version` is assigned as a variable (an array of string literal) - target ruby version > 2.6 - registers an offense when `required_ruby_version` is specified with >= and is higher than `TargetRubyVersion` - registers an offense when `required_ruby_version` is specified with ~> and is higher than `TargetRubyVersion` +RuboCop::Cop::Lint::SendWithMixinArgument + registers an offense when using `send` with `prepend` + registers an offense when using `__send__` method + does not register an offense when using `extend` + registers an offense when using `send` with `include` + does not register an offense when using `include` + registers an offense when using `send` with `extend` + registers an offense when using `public_send` method + does not register an offense when not using a mixin method + does not register an offense when using `prepend` + when using namespace for module + registers an offense when using `send` with `include` + when specifying a mixin method as a string + registers an offense when using `send` with `include` + registers an offense when using `send` with `extend` + registers an offense when using `send` with `prepend` -RuboCop::Cop::Style::FormatStringToken - ignores placeholder arguments - ignores `%r` regexp - ignores __FILE__ - ignores time format (when used as argument to strptime) - ignores time format when it is stored in a variable - handles dstrs - works inside hashes - ignores http links - supports flags and modifiers - ignores time format and unrelated `format` method using - ignores xstr - ignores time format (when used as argument to strftime) - ignores regexp - ignores percent escapes - behaves like enforced styles for format string tokens - when enforced style is template - configures the enforced style to template after inspecting "%{a}" - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is annotated - detects when the cop must be disabled to avoid offenses - sets the enforced style to annotated after inspecting "%s" - supports dynamic string with interpolation - registers offenses for template style - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - behaves like enforced styles for format string tokens - when enforced style is template - configures the enforced style to template after inspecting "%{a}" - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - registers offenses for template style - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is template - configures the enforced style to template after inspecting "%{a}" - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - does not register offenses for annotated style - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is annotated - registers offenses for template style - supports dynamic string with interpolation - sets the enforced style to annotated after inspecting "%s" - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - behaves like enforced styles for format string tokens - when enforced style is annotated - supports dynamic string with interpolation - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - sets the enforced style to annotated after inspecting "%s" - registers offenses for template style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - does not register offenses for annotated style - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - behaves like enforced styles for format string tokens - when enforced style is annotated - #correctable_sequence? - registers offenses for template style - supports dynamic string with interpolation - sets the enforced style to annotated after inspecting "%s" - detects when the cop must be disabled to avoid offenses - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - #correctable_sequence? - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is annotated - supports dynamic string with interpolation - sets the enforced style to annotated after inspecting "%s" - #correctable_sequence? - registers offenses for template style - detects when the cop must be disabled to avoid offenses - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when enforced style is template - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - does not register offenses for annotated style - configures the enforced style to template after inspecting "%{a}" - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - configures the enforced style to template after inspecting "%{a}" - does not register offenses for annotated style - supports dynamic string with interpolation - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is annotated - registers offenses for template style - sets the enforced style to annotated after inspecting "%s" - supports dynamic string with interpolation - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - gives a helpful error message - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - supports dynamic string with interpolation - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - registers offenses for template style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is template - supports dynamic string with interpolation - registers offenses for annotated style - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - configures the enforced style to template after inspecting "%{a}" - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - #correctable_sequence? - does not register offenses for annotated style - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - detects when the cop must be disabled to avoid offenses - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - detects when the cop must be disabled to avoid offenses - registers offenses for template style - #correctable_sequence? - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is template - configures the enforced style to template after inspecting "%{a}" - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - does not register offenses for annotated style - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - registers offenses for template style - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - does not register offenses for annotated style - detects when the cop must be disabled to avoid offenses - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - detects when the cop must be disabled to avoid offenses - registers offenses for template style - #correctable_sequence? - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is template - gives a helpful error message - when enforced style is annotated - gives a helpful error message - when AllowedMethods is disabled - registers an offense - when AllowedPatterns is disabled - registers an offense - when AllowedPatterns is enabled - does not register an offense - does not register an offense for value in nested structure - registers an offense for different method call within ignored method - when AllowedMethods is enabled - does not register an offense - registers an offense for different method call within ignored method - does not register an offense for value in nested structure - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is template - #correctable_sequence? - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is annotated - #correctable_sequence? - supports dynamic string with interpolation - detects when the cop must be disabled to avoid offenses - registers offenses for template style - sets the enforced style to annotated after inspecting "%s" - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - behaves like enforced styles for format string tokens - when enforced style is template - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - detects when the cop must be disabled to avoid offenses - sets the enforced style to annotated after inspecting "%s" - registers offenses for template style - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - behaves like enforced styles for format string tokens - when enforced style is annotated - detects when the cop must be disabled to avoid offenses - sets the enforced style to annotated after inspecting "%s" - #correctable_sequence? - supports dynamic string with interpolation - registers offenses for template style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when enforced style is template - does not register offenses for annotated style - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - configures the enforced style to template after inspecting "%{a}" - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - behaves like enforced styles for format string tokens - when enforced style is template - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - does not register offenses for annotated style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - supports dynamic string with interpolation - registers offenses for template style - sets the enforced style to annotated after inspecting "%s" - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - #correctable_sequence? - sets the enforced style to annotated after inspecting "%s" - registers offenses for template style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when enforced style is template - does not register offenses for annotated style - supports dynamic string with interpolation - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - configures the enforced style to template after inspecting "%{a}" - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is unannotated - #correctable_sequence? - when enforced style is annotated - sets the enforced style to annotated after inspecting "%s" - detects when the cop must be disabled to avoid offenses - #correctable_sequence? - registers offenses for template style - supports dynamic string with interpolation - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - registers offense for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is template - detects when the cop must be disabled to avoid offenses - supports dynamic string with interpolation - #correctable_sequence? - configures the enforced style to template after inspecting "%{a}" - does not register offenses for annotated style - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - behaves like enforced styles for format string tokens - when enforced style is annotated - supports dynamic string with interpolation - #correctable_sequence? - detects when the cop must be disabled to avoid offenses - registers offenses for template style - sets the enforced style to annotated after inspecting "%s" - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for single unannotated - registers offense for dual unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is template - detects when the cop must be disabled to avoid offenses - does not register offenses for annotated style - configures the enforced style to template after inspecting "%{a}" - supports dynamic string with interpolation - #correctable_sequence? - behaves like maximum allowed unannotated - when MaxUnannotatedPlaceholdersAllowed is 1 - does not register offenses for dual unannotated - does not register offenses for single unannotated - when MaxUnannotatedPlaceholdersAllowed is 2 - does not register offenses for single unannotated - does not register offenses for dual unannotated - when enforced style is unannotated - #correctable_sequence? - -RuboCop::Formatter::OffenseCountFormatter - #finished - when output tty is true - has a progress bar - when there are many offenses - when --display-style-guide was not given - sorts by offense count first and then by cop name - when --display-style-guide was given - shows links and sorts by offense count first and then by cop name - #file_finished - when no offenses are detected - does not add to offense_counts - when any offenses are detected - increments the count for the cop in offense_counts - #report_summary - when an offense is detected - shows the cop and the offense count - -RuboCop::Cop::Style::UnlessLogicalOperators - EnforcedStyle is `forbid_logical_operators` - registers an offense when using only `||` - registers an offense when using only `and` - does not register an offense when not using logical operator - registers an offense when using `&&` followed by || - does not register an offense when not used in unless - registers an offense when using only `or` - does not register an offense when using if - registers an offense when using only `&&` - EnforcedStyle is `forbid_mixed_logical_operators` - does not register an offense when not using logical operator - does not register an offense when using only `&&`s - does not register an offense when using `&&` operator and invoked method name includes "and" in the conditional branch - does not register an offense when not used in unless - does not register an offense when using `||` operator and invoked method name includes "or" in the conditional branch - does not register an offense when using only `and`s - registers an offense when using `&&` and `||` - registers an offense when using `&&` and `or` - does not register an offense when using only `||`s - registers an offense when using `||` and `or` - does not register an offense when using if - registers an offense when using parentheses - registers an offense when using `&&` and `and` - does not register an offense when using only `or`s - registers an offense when using `||` and `and` - -RuboCop::Cop::Layout::EmptyLinesAroundArguments - when no extra lines - accepts when blank line is inserted between method with arguments and receiver - accepts multiple listed mixed args - accepts method with argument that trails off block - accepts listed args starting on definition line - accepts multiline style argument for method call without selector - accepts block argument with empty line - accepts method with no arguments that trails off block - accepts one line methods - accepts method with argument that trails off heredoc - with one argument - ignores empty lines inside of method arguments - with multiple arguments - ignores empty lines inside of method arguments - when extra lines - registers and autocorrects offense when empty line between normal arg & block arg - registers and autocorrects offense for empty line before arg - registers autocorrects empty line whetn args start on definition line - registers and autocorrects offense on correct line for single offense example - registers and autocorrects offenses when multiple empty lines are detected - registers and autocorrects offense on correct lines for multi-offense example - registers and autocorrects offense for empty line after arg - registers and autocorrects offense for empty line between args - registers and autocorrects offense when args start on definition line - when using safe navigation operator - registers and autocorrects offense for empty line before arg - -RuboCop::Cop::Style::NumericLiteralPrefix - octal literals - when config is zero_only - does not register offense for prefix `0` - registers an offense for prefix `0O` and `0o` - when config is zero_with_o - does not register offense for lowercase prefix - registers an offense for prefixes `0` and `0O` - hex literals - does not register offense for lowercase prefix - registers an offense for uppercase prefix - binary literals - does not register offense for lowercase prefix - registers an offense for uppercase prefix - decimal literals - registers an offense for prefixes - does not register offense for no prefix - -RuboCop::Cop::Style::DocumentDynamicEvalDefinition - does not register an offense when using eval-type method with string interpolation with comment docs - does not register an offense when using eval-type method with interpolated string that is not heredoc with comment doc - does not register an offense when using eval-type method without string interpolation - registers an offense when using eval-type method with interpolated string that is not heredoc without comment doc - registers an offense when using eval-type method with string interpolation without comment docs - block comment outside heredoc - registers an offense if the comment does not match the method - does not register an offense for a matching block comment before the heredoc - does not register an offense when using other text - does not register an offense when using multiple methods - does not register an offense when using inline comments - does not register an offense for a matching block comment after the heredoc - block comment in heredoc - does not register an offense when using multiple methods - does not register an offense for a matching block comment - registers an offense if the comment does not match the method - does not register an offense when using other text - does not evaluate comments if there is no interpolation - does not register an offense when using multiple methods with split comments - does not register an offense when using inline comments - -RuboCop::Cop::Offense - overrides #to_s - does not blow up if a message contains % - is frozen - has a few required attributes - redefines == to compare offenses based on their contents - #<=> - when receiver has {:line=>6, :cop=>"A"} and other has {:line=>5, :cop=>"B"} - returns 1 - when receiver has {:line=>6, :col=>4} and other has {:line=>5, :col=>5} - returns 1 - when receiver has {:cop=>"B"} and other has {:cop=>"A"} - returns 1 - when receiver has {} and other has {} - returns 0 - when receiver has {:line=>5, :col=>6} and other has {:line=>5, :col=>5} - returns 1 - when receiver has {:col=>6, :cop=>"A"} and other has {:col=>5, :cop=>"B"} - returns 1 - when receiver has {:line=>6} and other has {:line=>5} - returns 1 - #severity_level - when severity is :refactor - is 2 - when severity is :fatal - is 6 - when severity is :info - is 1 - when the location is pseudo - returns a line - returns a column - returns a real column - returns the last column - returns a location with valid size and length - returns a column range - returns a source line - returns the last line - returns the first line - returns a column length - #severity - is frozen - offenses that span part of a line - highlights the first line - #message - is frozen - when unknown severity is passed - raises error - offenses that span multiple lines - highlights the first line - #location - is frozen - #cop_name - is frozen - -RuboCop::Cop::Style::InfiniteLoop - registers an offense for a while loop with {} as condition - registers an offense for a while loop with 2.0 as condition - registers an offense for modifier until false if loop {} would not change semantics - registers an offense for a while loop with [1] as condition - accepts while true if loop {} would change semantics - registers an offense for a while loop with 1 as condition - registers an offense for until false if loop {} would work because of previous assignment in a while loop - registers an offense for a until loop with nil as condition - registers an offense for while true or until false if loop {} would work because of an earlier assignment - registers an offense for while true if loop {} would work because it is an instance variable being assigned - accepts Kernel#loop - registers an offense for until false if loop {} would work because the assigned variable is not used afterwards - accepts modifier while true if loop {} would change semantics - registers an offense for a until loop with false as condition - behaves like autocorrector - autocorrects the usage of while without do - autocorrects the usage of while with do - autocorrects begin-end-while with one statement - autocorrects single line modifier while - autocorrects begin-end-while with two statements - autocorrects single line modifier while with and - with non-default indentation width - autocorrects multi-line modifier while and indents correctly - behaves like autocorrector - autocorrects begin-end-until with two statements - autocorrects begin-end-until with one statement - autocorrects single line modifier until - autocorrects the usage of until without do - autocorrects the usage of until with do - autocorrects single line modifier until with and - with non-default indentation width - autocorrects multi-line modifier until and indents correctly - -RuboCop::Formatter::WorstOffendersFormatter - #finished - when there are many offenses - sorts by offense count first and then by cop name - -RuboCop::Formatter::GitHubActionsFormatter - #finished - when file is relative to the current directory - reports offenses as error with the relative path - when offenses are detected - reports offenses as errors - when message contains % - escapes message - when fail level is defined - reports offenses below fail level as warnings - reports offenses above or at fail level as errors - when no offenses are detected - does not print anything - -RuboCop::Cop::Layout::FirstMethodArgumentLineBreak - ignores arguments without parens - registers an offense and corrects hash arg spanning multiple lines - ignores arguments listed on a single line - ignores kwargs listed on a single line when the arguments are used in `super` - ignores methods without arguments - registers an offense and corrects hash arg without a line break before the first pair - args listed on the first line - registers an offense and corrects - registers an offense and corrects using `super` - registers an offense and corrects using safe navigation operator - -RuboCop::DirectiveComment - #line_number - returns line number for directive - #all_cops? - when mentioned all - is expected to equal true - when mentioned specific cops - is expected to equal false - #match? - when disabled all cops - is expected to equal true - when cop names are superset of names - is expected to equal false - when cop names are same as in the comment - is expected to equal true - when cop names are same but in a different order - is expected to equal true - when cop names are subset of names - is expected to equal false - when there are no cop names - is expected to equal false - when cop names are same but have duplicated names - is expected to equal true - #match_captures - when todo - is expected to eq ["todo", "all", nil, nil] - when disable - is expected to eq ["disable", "all", nil, nil] - when enable - is expected to eq ["enable", "Foo/Bar", nil, "Foo/"] - when typo - is expected to be nil - #enabled? - when enable - is expected to equal true - when todo - is expected to equal false - when disable - is expected to equal false - #directive_count - when few cops used - is expected to eq 2 - when cops and departments used - is expected to eq 4 - when few department used - is expected to eq 3 - #overridden_by_department? - when cop is overridden by it's department - is expected to equal true - when there are no departments - is expected to equal false - when cop is not overridden by it's department - is expected to equal false - when there are no cops - is expected to equal false - #cop_names - when couple departments specified - is expected to eq ["Foo/Bar", "Foo/Baz", "Baz/Bar"] - when only department specified - is expected to eq ["Foo/Bar", "Foo/Baz"] - when department and cops specified - is expected to eq ["Foo/Bar", "Foo/Baz", "Baz/Cop"] - when only cop specified - is expected to eq ["Foo/Bar"] - when all cops mentioned - is expected to eq ["all_names"] - when redundant directive cop department specified - is expected to eq ["Lint/One", "Lint/Two"] - .before_comment - when line has code - is expected to eq "def foo " - when line has NO code - is expected to eq "" - #in_directive_department? - when another department disabled - is expected to equal false - when cop disabled - is expected to equal false - when cop department disabled - is expected to equal true - #enabled_all? - when disabled specific cops - is expected to equal false - when enabled all cops - is expected to equal true - when disabled all cops - is expected to equal false - when enabled specific cops - is expected to equal false - #disabled_all? - when enabled specific cops - is expected to equal false - when enabled all cops - is expected to equal false - when disabled specific cops - is expected to equal false - when disabled all cops - is expected to equal true - #disabled? - when disable - is expected to equal true - when enable - is expected to equal false - when todo - is expected to equal true - #single_line? - when does NOT relate to single line - is expected to equal false - when relates to single line - is expected to equal true - #department_names - when only cop specified - is expected to eq [] - when only department specified - is expected to eq ["Foo"] - when all cops mentioned - is expected to eq [] - when couple departments specified - is expected to eq ["Foo", "Baz"] - when department and cops specified - is expected to eq ["Foo"] +RuboCop::TargetFinder + #find(..., :only_recognized_file_types) + does not find hidden files + returns absolute paths + when a hidden directory path is passed + finds files under the specified directory + when a hidden directory path is passed + finds files under the specified directory + when files with ruby interpreters are passed + picks all the ruby files + when files with a ruby extension are passed + picks all the ruby files + when local AllCops/Include lists two patterns + picks two files + when a subdirectory AllCops/Include only lists one pattern + picks two files + when some non-known Ruby files are specified in the configuration Include and they are explicitly passed as arguments + includes them + when some non-known Ruby files are specified in the configuration Include and they are not explicitly passed as arguments + includes them + when a pattern is passed + finds files which match the pattern + when input is passed on stdin + includes the file + when a directory path is passed + finds files under the specified directory + when a file with a ruby filename is passed + picks all the ruby files + when same paths are passed + does not return duplicated file paths + when no argument is passed + finds files under the current directory + when some paths are specified in the configuration Exclude and they are explicitly passed as arguments + when it's forced to adhere file exclusion configuration + excludes them + normally + does not exclude them + when a non-ruby file is passed + doesn't pick the file + #find(..., :all_file_types) + does not find hidden files + returns absolute paths + when files with ruby interpreters are passed + picks all the ruby files + when input is passed on stdin + includes the file + when a non-ruby file is passed + picks the file + when files with a ruby extension are passed + picks all the ruby files + when local AllCops/Include lists two patterns + picks all the ruby files + when a subdirectory AllCops/Include only lists one pattern + picks all the ruby files + when no argument is passed + finds files under the current directory + when some non-known Ruby files are specified in the configuration Include and they are not explicitly passed as arguments + includes them + when some non-known Ruby files are specified in the configuration Include and they are explicitly passed as arguments + includes them + when same paths are passed + does not return duplicated file paths + when a hidden directory path is passed + finds files under the specified directory + when a file with a ruby filename is passed + picks all the ruby files + when a directory path is passed + finds files under the specified directory + when a pattern is passed + finds files which match the pattern + when some paths are specified in the configuration Exclude and they are explicitly passed as arguments + normally + does not exclude them + when it's forced to adhere file exclusion configuration + excludes them + #find_files + prevents infinite loops when traversing symlinks + works also if a folder is named "," + works also if a folder is named "{}" + works also if a folder is named "**" + does not search excluded top level directories + can exclude symlinks as well as directories + resolves symlinks when looking for excluded directories + #target_files_in_dir + does not pick directories + does not pick files specified to be excluded in config + does not pick files with no extension and no ruby shebang + picks ruby executable files with no extension + picks files with extension .rb + picks files specified to be included in config + when an exception is raised while reading file + and debug mode is disabled + outputs nothing + and debug mode is enabled + outputs error message + w/ --fail-fast option + works with the expected number of .rb files -RuboCop::Cop::Naming::VariableName - when configured for camelCase - registers an offense for keyword rest arguments - registers an offense for rest arguments - registers an offense for opposite + correct - registers an offense for snake case in local variable name - accepts camel case in instance variable name - accepts camel case in class variable name - registers an offense for default method arguments - registers an offense for keyword arguments - registers an offense for block arguments - accepts with non-ascii characters - accepts screaming snake case constants - accepts one symbol size local variables - registers an offense for snake case in method parameter - accepts local variables marked as unused - accepts screaming snake case globals - registers an offense for camel case when invoking method args - accepts assigning to camel case constant - accepts assignment with indexing of self - accepts camel case local variables marked as unused - accepts camel case in local variable name - when AllowedIdentifiers is set - does not register an offense for a method name that is allowed - does not register an offense for a symbol that is allowed - does not register an offense for a instance variable name that is allowed - does not register an offense for a global variable name that is allowed - does not register an offense for a class variable name that is allowed - does not register an offense for a local variable name that is allowed - when AllowedPatterns is set - does not register an offense for a symbol that matches the allowed pattern - does not register an offense for a local variable name that matches the allowed pattern - does not register an offense for a instance variable name that matches the allowed pattern - does not register an offense for a global variable name that matches the allowed pattern - does not register an offense for a class variable name that matches the allowed pattern - does not register an offense for a method name that matches the allowed pattern - when configured for snake_case - registers an offense for camel case local variables marked as unused - accepts assignment with indexing of self - registers an offense for default method arguments - registers an offense for correct + opposite - registers an offense for keyword rest arguments - accepts screaming snake case globals - registers an offense for camel case in class variable name - accepts one symbol size local variables - registers an offense for keyword arguments - registers an offense for camel case in instance variable name - accepts screaming snake case constants - registers an offense for block arguments - registers an offense for rest arguments - registers an offense for camel case when invoking method args - registers an offense for method arguments - accepts assigning to camel case constant - registers an offense for camel case in local variable name - accepts local variables marked as unused - when AllowedIdentifiers is set - does not register an offense for a symbol that is allowed - does not register an offense for a local variable name that is allowed - does not register an offense for a instance variable name that is allowed - does not register an offense for a method name that is allowed - does not register an offense for a class variable name that is allowed - does not register an offense for a global variable name that is allowed - when AllowedPatterns is set - does not register an offense for a method name that matches the allowed pattern - does not register an offense for a local variable name that matches the allowed pattern - does not register an offense for a instance variable name that matches the allowed pattern - does not register an offense for a class variable name that matches the allowed pattern - does not register an offense for a symbol that matches the allowed pattern - does not register an offense for a global variable name that matches the allowed pattern +RuboCop::Cop::Lint::TopLevelReturnWithArgument + Code segment with method-level return statements + expects offense when method-level & top-level return co-exist + Code segment with block level returns other than the top-level return + expects offense from the return with arguments + expects no offense from the return without arguments + Code segment with inline if along with top-level return + expects no offense from the return without arguments + expects multiple offense from the return with arguments + Code segment with only top-level return statement + expects offense from the return with arguments + expects no offense from the return without arguments + expects multiple offenses from the return with arguments statements + Code segment containing semi-colon separated statements + expects no offense from the return with arguments and multi-line code + expects an offense from the return with arguments and multi-line code -RuboCop::Cop::Lint::ErbNewArguments - >= Ruby 2.6 - registers an offense when using `ERB.new` with non-keyword 2nd and 3rd arguments andkeyword 4th argument - registers an offense when using `ERB.new` with non-keyword 2nd argument - registers an offense when using `ERB.new` with non-keyword 2nd, 3rd and 4th arguments andkeyword 5th argument - registers an offense when using `ERB.new` with non-keyword 2nd and 3rd arguments - registers an offense when using `::ERB.new` with non-keyword 2nd, 3rd and 4th arguments - does not register an offense when using `ERB.new` without optional arguments - registers an offense when using `ERB.new` with non-keyword 2nd, 3rd and 4th arguments - does not register an offense when using `ERB.new` with keyword arguments - when using `ActionView::Template::Handlers::ERB.new` - does not register an offense when using `ERB.new` without arguments - <= Ruby 2.5 - does not register an offense when using `ERB.new` with non-keyword arguments +RuboCop::Cop::Style::TrailingUnderscoreVariable + configured to allow named underscore variables + registers an offense for multiple underscore variables preceded by a splat underscore variable + does not register an offense for a named underscore variable preceded by a splat variable + does not register an offense for multiple underscores preceded by a splat variable + does not register an offense for complex nested assignments without trailing underscores + registers an offense when underscore is the second to last variable and blank is the last variable + registers an offense when the last variable of parallel assignment is an underscore + registers an offense for complex nested assignments with trailing underscores + does not register an offense for underscores at the beginning + does not register an offense for a named splat underscore as the last variable + does not register an offense for an underscore preceded by a splat variable + registers an offense for an underscore as the last param when there is also an underscore as the first param + registers an offense for nested assignments with trailing underscores + registers an offense when underscore is the only variable in parallel assignment + does not register an offense when there are no underscores + does not register an offense for a named variable preceded by a names splat underscore variable + registers an offense when multiple underscores are used as the last variables of parallel assignment + does not register an offense for nested assignments without trailing underscores + registers an offense for splat underscore as the last variable + does not register an offense for an underscore variable preceded by a named splat underscore variable + does not register an offense for multiple named underscores preceded by a splat variable + does not register an offense for an underscore preceded by a splat variable anywhere in the argument chain + does not register an offense for named variables that start with an underscore + does not register an offense for an underscore preceded by a splat variable and another underscore + does not register an offense for multiple underscore variables preceded by a named splat underscore variable + autocorrect + with parentheses + leaves parentheses but removes trailing underscores and commas + leaves parentheses but removes trailing underscores + removes assignment part when every assignment is to `_` + removes assignment part when it is the only variable + configured to not allow named underscore variables + registers an offense for multiple underscore variables preceded by a named splat underscore variable + does not register an offense for a named underscore preceded by a splat variable + does not register an offense for an underscore preceded by a splat variable and another underscore + does not register an offense for nested assignments without trailing underscores + does not register an offense for a named underscore variable preceded by a splat variable + does not register an offense for an underscore preceded by a splat variable + registers an offense for an underscore as the last param when there is also an underscore as the first param + registers an offense for named variables that start with an underscore + registers an offense when underscore is the only variable in parallel assignment + registers an offense for an underscore variable preceded by a named splat underscore variable + does not register an offense for an underscore preceded by a splat variable anywhere in the argument chain + does not register an offense for a named variable preceded by a names splat underscore variable + registers an offense for multiple underscore variables preceded by a splat underscore variable + does not register an offense for underscores at the beginning + registers an offense when the last variable of parallel assignment is an underscore + does not register an offense for multiple named underscores preceded by a splat variable + registers an offense for complex nested assignments with trailing underscores + does not register an offense for multiple underscores preceded by a splat variable + registers an offense for an underscore preceded by a named splat underscore + registers an offense for nested assignments with trailing underscores + registers an offense for a named splat underscore as the last variable + registers an offense when underscore is the second to last variable and blank is the last variable + registers an offense for splat underscore as the last variable + does not register an offense when there are no underscores + registers an offense when multiple underscores are used as the last variables of parallel assignment + does not register an offense for complex nested assignments without trailing underscores + autocorrect + with parentheses + leaves parentheses but removes trailing underscores + removes assignment part when it is the only variable + leaves parentheses but removes trailing underscores and commas + removes assignment part when every assignment is to `_` -RuboCop::Cop::Metrics::BlockLength - does not count blank lines - rejects a block with more than 5 lines - reports the correct beginning and end lines - accepts a block with less than 3 lines - rejects brace blocks too - accepts empty blocks - properly counts nested blocks - does not count commented lines by default - accepts a block with multiline receiver and less than 3 lines of body - when methods to allow are defined - when ExcludedMethods is enabled - does not report an offense - that does not match - reports an offense - when AllowedMethods is enabled - when a method is allowed, but receiver is a module - does not report an offense - behaves like allow an offense on an allowed method - still rejects other methods with long blocks - accepts the foo method with a long block - behaves like allow an offense on an allowed method - still rejects other methods with long blocks - accepts the foo method with a long block - when receiver contains whitespaces - allows whitespaces - when AllowedPatterns is enabled - does not report an offense - that does not match - reports an offense - when IgnoredMethods is enabled - when string - does not report an offense - that does not match - reports an offense - when regex - does not report an offense - that does not match - reports an offense - when `CountAsOne` is not empty - folds array into one line - when defining a class - does not register an offense - when defining a Struct - does not register an offense - when using numbered parameter - reports the correct beginning and end lines - rejects a block with more than 5 lines - accepts a block with less than 3 lines - does not count blank lines - when CountComments is enabled - also counts commented lines - when defining a module - does not register an offense +RuboCop::Cop::Layout::EmptyLinesAroundAttributeAccessor + accepts code that separates attribute accessors from the code with a newline + registers an offense and corrects for some attribute accessors and comment line + registers an offense and corrects for code that immediately follows accessor + registers an offense and corrects for an attribute accessor and `rubocop:disable` comment line + accepts code that where the attr_accessor is the last line + accepts code when used in class definition + registers an offense and corrects for an attribute accessor and comment line + registers an offense and corrects for code that immediately follows accessor with comment + does not register an offense and corrects when using `if` ... `else` branches + accepts code that separates an attribute accessor from the code and `rubocop:enable` comment line with a newline + registers an offense and corrects for an attribute accessor and `rubocop:enable` comment line + accepts code that separates an attribute accessor from the code with a newline + accepts code that separates attribute accessors from the code and comment line with a newline + accepts code when attribute method is method chained + registers an offense and corrects for an attribute accessor and some comment line + registers an offense and corrects for an attribute accessor and `rubocop:enable` comment line and other comment + when `AllowAliasSyntax: false` + registers an offense for code that immediately `alias` syntax after accessor + when `AllowedMethods: []` + registers an offense for code that immediately ignored methods after accessor + when `AllowedMethods: private` + does not register an offense for code that immediately ignored methods after accessor + when `AllowAliasSyntax: true` + does not register an offense for code that immediately `alias` syntax after accessor -RuboCop::Cop::Style::TrailingCommaInHashLiteral - with single line list of values - when EnforcedStyleForMultiline is no_comma - registers an offense for trailing comma in a literal - accepts single element literal without trailing comma - accepts empty literal - accepts literal without trailing comma - when EnforcedStyleForMultiline is consistent_comma - accepts single element literal without trailing comma - accepts empty literal - accepts literal without trailing comma - registers an offense for trailing comma in a literal - when EnforcedStyleForMultiline is comma - registers an offense for trailing comma in a literal - accepts literal without trailing comma - accepts empty literal - accepts single element literal without trailing comma - with multi-line list of values - when EnforcedStyleForMultiline is consistent_comma - accepts trailing comma after a heredoc - accepts a multiline hash with a single pair and trailing comma - registers an offense for no trailing comma - accepts a multiline hash with pairs on a single line andtrailing comma - accepts trailing comma - when closing bracket is on same line as last value - registers an offense for literal with no trailing comma - when EnforcedStyleForMultiline is no_comma - accepts comma in comment after last value item - accepts comma inside a heredoc parameters at the end - registers an offense for trailing comma in literal - accepts literal with no trailing comma - when EnforcedStyleForMultiline is comma - registers an offense for no trailing comma - accepts trailing comma - accepts trailing comma after a heredoc - accepts a multiline hash with a single pair and trailing comma - registers an offense for trailing comma in a comment - when closing bracket is on same line as last value - accepts literal with no trailing comma +RuboCop::Cop::Style::TopLevelMethodDefinition + does not register an offense when define_method is not top-level + does not register an offense when using Struct + registers an offense top-level methods + does not register an offense when defined within arbitrary block + does not register an offense when using module + does not register an offense when just called method on top-level + does not register an offense when using class + registers an offense top-level class methods + registers an offense when defining a top-level method after a class definition + top-level define_method + registers offense with inline block + registers offense for proc argument + registers offense for multi-line block + Ruby >= 2.7 + registers offense with inline numblock -RuboCop::Formatter::FuubarStyleFormatter - #progressbar_color - when no offenses are detected in a file - is still green - when a offense is detected in a file and autocorrected - is green - when a convention offense is detected in a file - is yellow - initially - is green - when an error offense is detected in a file - is red - and then a convention offense is detected in the next file - is still red - when convention and error offenses are detected in a file - is red - #with_color - when color is disabled - outputs nothing - when color is enabled - outputs coloring sequence code at the beginning and the end +RuboCop::Cop::Style::StderrPuts + registers no offense when using `STDERR.puts` with no arguments + registers an offense when using `::STDERR.puts('hello')` + registers an offense when using `STDERR.puts('hello')` + registers an offense when using `$stderr.puts('hello')` + registers no offense when using `$stderr.puts` with no arguments RuboCop::Cop::Layout::LeadingEmptyLines - registers an offense and corrects a new line before a comment + registers an offense and corrects a new line before code + registers an offense and corrects multiple new lines before a class accepts not having a blank line before code - allows blank lines without any comments or code - accepts not having a blank line before a comment registers an offense and corrects a new line before a class - allows an empty input + registers an offense and corrects a new line before a comment + accepts not having a blank line before a comment accepts not having a blank line before a class - registers an offense and corrects multiple new lines before a class - registers an offense and corrects a new line before code + allows blank lines without any comments or code + allows an empty input autocorrect in collaboration does not invoke conflicts with other cops -RuboCop::Cop::Style::AndOr - when style is always - autocorrects "or" with an assignment on the right - autocorrects "and" with an Enumerable accessor on either side - warns on short-circuit (and) - autocorrects "or" inside def - autocorrects "or" with || in method calls (3) - also warns on until (or) - autocorrects "or" with || in method calls - autocorrects "or" with || in method calls (2) - autocorrects "or" with an assignment on the left - registers an offense for "and" - autocorrects "and" with && in method calls - autocorrects "or" with || and adds parentheses to expr - also warns on non short-circuit (and) (unless) - autocorrects "and" inside def - also warns on non short-circuit (and) - also warns on while (and) - autocorrects "and" with && in method calls (4) - also warns on non short-circuit (or) - autocorrects "and" with && in method calls (3) - also warns on until (and) - autocorrects "or" with || and doesn't add extra parentheses - also warns on non short-circuit (or) (unless) - autocorrects "and" with && and adds parentheses to expr - autocorrects "or" with || in method calls (4) - registers an offense for "or" - also warns on while (or) - autocorrects "and" with && in method calls (2) - warns on short-circuit (or) - autocorrects "and" with && and doesn't add extra parentheses - with obj.method= arg on left - autocorrects "and" with && and adds parens - within a nested begin node - autocorrects "and" with && and adds parens - with predicate method with arg without space on right - autocorrects "and" with && and adds parens - autocorrects "or" with || and adds parens - when `and` precedes `or` - registers an offense and corrects - with two predicate methods with args without spaces on right - autocorrects "and" with && and adds parens - autocorrects "or" with || and adds parens - with one predicate method without space on right and another method - autocorrects "or" with || and adds parens - autocorrects "and" with && and adds parens - when `and` precedes `||` - registers an offense and corrects - with !variable on left - doesn't crash and burn - with !obj.method arg on right - autocorrects "and" with && and adds parens - when `or` precedes `&&` - registers an offense and corrects - with obj.method = arg on left - autocorrects "and" with && and adds parens - with `not` expression on left - autocorrects "and" with && and adds parens - with `not` expression on right - autocorrects "and" with && and adds parens - when left hand side is a comparison method - autocorrects "and" with && and adds parens - when `or` precedes `and` - registers an offense and corrects - with a file which contains __FILE__ - autocorrects "or" with || - within a nested begin node with one child only - autocorrects "and" with && and adds parens - with !obj.method arg on left - autocorrects "and" with && and adds parens - when style is conditionals - registers an offense for "and" in post-until condition - accepts "or" outside of conditional - registers an offense for "and" in if condition - registers an offense for "or" in post-while condition - registers an offense for "and" in until condition - accepts "and" in until body - registers an offense for "or" in until condition - accepts "and" outside of conditional - accepts "and" in while body - accepts || outside of conditional - accepts "and" in post-until body - accepts && inside of conditional - registers an offense for "or" in post-until condition - registers an offense for "or" in while condition - registers an offense for "and" in post-while condition - accepts || inside of conditional - accepts "and" in post-while body - accepts "or" in post-while body - accepts "or" in while body - accepts "or" in post-until body - accepts "or" in if body - registers an offense for "and" in while condition - accepts "and" in if body - registers an offense for "or" in if condition - accepts "or" in until body - accepts && outside of conditional +RuboCop::Cop::Lint::DeprecatedClassMethods + prefer `File.exist?` over `File.exists?` + registers an offense and corrects ::File.exists? + registers an offense and corrects File.exists? + does not register an offense for File.exist? + when using `ENV.clone` + registers an offense + does not register an offense for method calls to `ENV` other than `clone` + prefer `block_given?` over `iterator?` + does not register an offense for offensive method `iterator?`on other receivers + registers an offense and corrects iterator? + does not register an offense for block_given? + when using `ENV.dup` + registers an offense + does not register an offense for method calls to `ENV` other than `dup` + when using `ENV.freeze` + does not register an offense for method calls to `ENV` other than `freeze` + registers an offense + prefer `Addrinfo#getnameinfo` over `Socket.gethostbyaddr` + registers an offense for Socket.gethostbyaddr + registers an offense for ::Socket.gethostbyaddr + does not register an offense for method `gethostbyaddr` on other receivers + prefer `Addrinfo#getaddrinfo` over `Socket.gethostbyname` + registers an offense for Socket.gethostbyname + does not register an offense for method `gethostbyname` on other receivers + registers an offense for ::Socket.gethostbyname + prefer `Dir.exist?` over `Dir.exists?` + registers an offense and corrects ::Dir.exists? + does not register an offense for offensive method `exists?`on other receivers + does not register an offense for Dir.exist? + registers an offense and corrects Dir.exists? -RuboCop::Cop::Style::ConstantVisibility - does not register an offense when passing a string to the visibility declaration - registers an offense for module definitions - does not register an offense in the top level scope - IgnoreModules - does not register an offense for class definitions - registers an offense for constants - when defining a constant in a class - with a single-statement body - registers an offense when not using a visibility declaration - with a multi-statement body - does not register an offense when using a visibility declaration - registers an offense when not using a visibility declaration - registers an offense when there is no matching visibility declaration - when defining a constant in a module - does not register an offense when using a visibility declaration - registers an offense when not using a visibility declaration +RuboCop::Cop::Lint::EmptyExpression + when used as a standalone expression + registers an offense + with nested empty expressions + registers an offense + when used as an assignment + registers an offense for the assigned value + when used in a condition + registers an offense in the return value of a ternary operator + registers an offense in the condition of a ternary operator + registers an offense inside `when` + registers an offense inside `if` + registers an offense inside `case` + registers an offense inside `elsif` + when used as a return value + registers an offense in the return value of a case statement + registers an offense in the return value of a method + registers an offense in the return value of a condition -RuboCop::Cop::Style::MultipleComparison - registers an offense and corrects when `a` is compared twice in `if` and `elsif` conditions - registers an offense and corrects when `a` is compared three times on the right hand side - registers an offense and corrects when `a` is compared three times - does not register an offense for comparing multiple int literals - registers an offense and corrects when `a` is compared three times, once on the righthand side - does not register an offense for comparing multiple literal strings - does not register an offense for comparing lvars - registers an offense and corrects when `a` is compared twice - registers an offense and corrects when multiple comparison is not part of a conditional - does not register an offense when comparing two sides of the disjunction is unrelated - does not register an offense for Array#include? - does not register an offense for a duplicated condition - does not register an offense for comparing lvars when a string is on the lefthand side - does not register an offense for a == b || b == a - does not register an offense for comparing an lvar - when `AllowMethodComparison: false` - registers an offense and corrects when using multiple method calls - when `AllowMethodComparison: true` - does not register an offense when using multiple method calls +RuboCop::Cop::Layout::ArgumentAlignment + aligned with first argument + registers an offense and corrects multiline missed indentation + accepts correctly aligned arguments with fullwidth characters + accepts braceless hashes + can handle a string literal as other argument + doesn't get confused by symbols with embedded expressions + can handle do-end + registers an offense and corrects splat operator + doesn't crash and burn when there are nested issues + doesn't get confused by extra comma at the end + registers an offense and corrects multi-line outdented parameters + can handle method calls without parentheses + registers an offense and corrects arguments with single indent + can handle a call with a block inside another call + accepts correctly aligned arguments + doesn't get confused by a symbol argument + doesn't get confused by a line break inside a parameter + registers an offense and corrects arguments with double indent + can handle other method calls without parentheses + can handle a method call within a method call + doesn't get confused by regexen with embedded expressions + can handle a multiline hash as second parameter + registers an offense and corrects when missed indentation kwargs + registers an offense and correct multi-line parametersindented too far + accepts the first parameter being on a new row + can handle parentheses used with no arguments + does not crash in autocorrect on dynamic string in parameter value + can handle a call embedded in a string + accepts calls that only span one line + accepts multiline []= method call + can handle a ternary condition with a block reference + can handle heredoc strings + can handle a correctly aligned string literal as first argument + when using safe navigation operator + registers an offense and corrects arguments with single indent + assigned methods + accepts the first parameter being on a new row + accepts the first parameter being on method row + aligned with fixed indentation + does not register an offense when using aligned braced hash as a argument + autocorrects when first line is indented + corrects indentation for kwargs starting on same line as other args + autocorrects by indenting when not indented + registers an offense and corrects when missed indentation kwargs + autocorrects by outdenting when indented too far + assigned methods + with IndentationWidth:Width set to 4 + accepts the first parameter being on method row + autocorrects even when first argument is in wrong position + accepts the first parameter being on a new row + with ArgumentAlignment:IndentationWidth set to 4 + accepts the first parameter being on a new row + accepts the first parameter being on method row + multi-line method calls + does not err on method call without a method name + registers offenses and corrects double indentation from relevant method + can handle existing indentation from multi-line method calls + autocorrects relative to position of relevant method call -RuboCop::Cop::Style::SpecialGlobalVars - when style is use_perl_names - registers an offense for $LOADED_FEATURES - registers an offense for $LOAD_PATH - autocorrects $INPUT_RECORD_SEPARATOR to $/ - registers an offense for $PROGRAM_NAME - autocorrects #{$LOAD_PATH} to #$: - registers an offense for $PROCESS_ID - does not register an offense for backrefs like $1 - registers an offense for $PID - when style is use_english_names - when add require English is disabled - registers an offense for $" - does not register an offense for backrefs like $1 - registers an offense for $: - generates correct auto-config when mixed styles are used - autocorrects $/ to $INPUT_RECORD_SEPARATOR - autocorrects #{$!} to #{$ERROR_INFO} - registers an offense for $$ - autocorrects #$: to #{$LOAD_PATH} - generates correct auto-config when Perl variable names are used - registers an offense for $0 - is clear about variables from the English library vs those not - when add require English is enabled - when English has not been required at top-level - adds require English for $$ - adds require English for twice `$*` in nested code - adds require English for $$ in nested code - does not add for replacement outside of English lib - when English is already required at top-level - moves require English above replacement - leaves require English alone for $$ - when style is use_builtin_english_names - generates correct auto-config when Perl variable names are used - does not register an offenses for builtin names - generates correct auto-config when mixed styles are used - does not register an offense for Perl names - does not register an offense for backrefs like $1 - autocorrects non-preffered builtin names +RuboCop::Cop::Style::EmptyBlockParameter + accepts a block that is do-end style without parameter + accepts an empty block parameter with a lambda + accepts a non-empty block parameter with do-end style + registers an offense for an empty block parameter with lambda + registers an offense for an empty block parameter with super + registers an offense for an empty block parameter with {} style + accepts a block that is {} style without parameter + registers an offense for an empty block parameter with do-end style + accepts a non-empty block parameter with {} style -RuboCop::Cop::Style::HashSyntax - configured to enforce explicit hash value syntax style - Ruby <= 3.0 - does not register an offense when hash key and hash value are the same - Ruby >= 3.1 - registers and corrects an offense when hash key and hash value are partially the same - does not register an offense when hash key and hash value are not the same - does not register an offense when hash key and hash value are the same - registers and corrects an offense when hash values are omitted - configured to enforce no mixed keys - accepts new syntax in a hash literal - accepts new hash style - accepts hash rockets in method calls - accepts old hash rockets style - accepts hash rockets when keys have different types - accepts hash rockets when keys start with a digit - registers an offense for mixed syntax when new is possible - registers an offense when keys have special symbols and mix styles - registers an offense when keys have whitespaces and mix styles - registers an offense when keys start with a digit and mix styles - accepts the hash rocket syntax when new is possible - accepts hash rockets when keys have whitespaces in them - accepts hash rockets when keys have special symbols in them - registers an offense when keys have different types and styles - accepts an empty hash - autocorrects mixed key hashes - accepts new syntax in method calls - configured to enforce ruby 1.9 style with no mixed keys - UseHashRocketsWithSymbolValues disabled - registers an offense when keys have special symbols in them - registers an offense when keys have whitespaces in them - registers an offense for mixed syntax when new is possible - registers an offense for hash rockets in method calls - accepts new syntax in a hash literal - registers offense for hash rocket syntax when new is possible - accepts new syntax in method calls - accepts hash rockets when keys have different types - accepts new syntax when keys are interpolated string - accepts an empty hash - registers an offense when keys start with a digit - registers an offense when keys have different types and styles - ruby < 2.2 - accepts hash rockets when keys have whitespaces in them - registers an offense when keys start with a digit and mix styles - registers an offense when keys have special symbols and mix styles - accepts hash rockets when keys start with a digit - accepts hash rockets when keys have special symbols in them - registers an offense when keys have whitespaces and mix styles - UseHashRocketsWithSymbolValues enabled - registers offense for hash rocket syntax when new is possible - registers an offense when keys have different types and styles - accepts new syntax in a hash literal - registers an offense for mixed syntax when new is possible - accepts new syntax when keys are interpolated string - registers an offense for hash rockets in method calls - registers an offense when keys start with a digit - accepts hash rockets when keys have different types - registers an offense when keys have special symbols in them - autocorrects to hash rockets when all elements have symbol value - accepts new syntax in method calls - registers an offense when keys have whitespaces in them - registers an offense when any element has a symbol value in method calls - registers an offense when any element uses a symbol for the value - accepts an empty hash - ruby < 2.2 - registers an offense when keys have whitespaces and mix styles - accepts hash rockets when keys start with a digit - accepts hash rockets when keys have whitespaces in them - accepts hash rockets when keys have special symbols in them - registers an offense when keys have special symbols and mix styles - registers an offense when keys start with a digit and mix styles - configured to accept both shorthand and explicit use of hash literal value - Ruby >= 3.1 - does not register an offense when hash key and hash value are the same - does not register an offense when hash key and hash value are partially the same - does not register an offense when hash values are omitted - does not register an offense when hash key and hash value are not the same - Ruby <= 3.0 - does not register an offense when hash key and hash value are the same - configured to disallow mixing of implicit and explicit hash literal value - Ruby <= 3.0 - does not register an offense when all hash key and hash values are the same - Ruby >= 3.1 - does not register an offense when all hash values are present, but only some values can be omitted - registers an offense when some hash values are omitted but they can all be omitted - registers an offense when some hash values are omitted but they cannot all be omitted - does not register an offense when all hash values are present, but no values can be omitted - does not register an offense when all hash values are omitted - registers an offense when all hash values are present, but can all be omitted - configured to enforce ruby19 style - with SpaceAroundOperators disabled - autocorrects even if there is no space around => - configured to use hash rockets when symbol values are found - registers an offense when using hash rockets and no elements have a symbol value - accepts ruby19 syntax when no elements have symbol values - accepts ruby19 syntax when no elements have symbol values in method calls - registers an offense when any element has a symbol value in method calls - accepts both hash rockets and ruby19 syntax in the same code - registers an offense when any element uses a symbol for the value - registers an offense for hashes with elements on multiple lines - autocorrects to hash rockets when all elements have symbol value - accepts an empty hash - accepts hash in ruby19 style with no symbol values - with SpaceAroundOperators enabled - accepts hash rockets when keys have different types - registers an offense when symbol keys have strings in them - registers an offense for hash rockets in method calls - autocorrects even if it interferes with SpaceAroundOperators - registers an offense for mixed syntax when new is possible - accepts new syntax in a hash literal - accepts new syntax in method calls - registers offense when keys start with an uppercase letter - accepts hash rockets when symbol characters are not supported - accepts an empty hash - accepts hash rockets when symbol keys end with = - registers offense for hash rocket syntax when new is possible - autocorrects a missing space when hash is used as argument - preserves quotes during autocorrection - ruby < 2.2 - accepts hash rockets when symbol keys have string in them - if PreferHashRocketsForNonAlnumEndingSymbols is true - accepts hash rockets when symbols end with ! - accepts hash rockets when symbols end with ? - if PreferHashRocketsForNonAlnumEndingSymbols is false - registers an offense for hash rockets when symbols end with ? - registers an offense for hash rockets when symbols end with ! - when using a return value uses `return` - registers an offense and corrects when enclosed in parentheses - registers an offense and corrects when not enclosed in parentheses - configured to enforce hash rockets style - accepts an empty hash - registers offense for Ruby 1.9 style - registers an offense for 1.9 style in method calls - accepts hash rockets in method calls - registers an offense for mixed syntax - accepts hash rockets in a hash literal - UseHashRocketsWithSymbolValues has no impact - does not register an offense when there is a symbol value - configured to enforce shorthand syntax style - Ruby <= 3.0 - does not register an offense when hash key and hash value are the same - Ruby >= 3.1 - registers and corrects an offense when `Hash[foo: foo]` and an expression follows - does not register an offense when lvar hash key and hash value are the same - does not register an offense when method call hash key and hash value are the same - registers and corrects an offense when hash key and hash value (lvar) are the same - does not register an offense when hash values are omitted - does not register an offense when without parentheses call expr follows - does not register an offense when symbol hash key and string hash value are the same - does not register an offense when with parentheses call expr follows assignment expr - registers and corrects an offense when hash key and hash value are the same - does not register an offense when hash key and hash value are not the same - does not register an offense when symbol hash key and hash value (lvar) are not the same - does not register an offense when one line `until` condition follows (without parentheses) - does not register an offense when hash key and hash value are partially the same - registers and corrects an offense when hash key and hash value are the same and it in the method bodyand an expression follows - does not register an offense when hash key and hash value are the same but the value ends `?` - registers and corrects an offense when `Hash[foo: foo]` - registers an offense when one line `if` condition follows (with parentheses) - does not register an offense when hash key and hash value are the same but the value ends `!` - does not register an offense when `return` with one line `if` condition follows (without parentheses) - does not register an offense when without parentheses call expr follows after nested method call - registers and corrects an offense when hash key and hash value are the same and it in the method body - does not register an offense when call expr without arguments and with a block follows - registers and corrects an offense when hash key and hash value are partially the same - does not register an offense when with parentheses call expr follows - does not register an offense when call expr with argument and a block follows - registers an offense when one line `until` condition follows (with parentheses) - does not register an offense when one line `if` condition follows (without parentheses) - does not register an offense when hash pattern matching - registers an offense when hash key and hash value are not the same and method with `[]` is called - when hash roket syntax - does not register an offense +RuboCop::Formatter::ProgressFormatter + #finished + calls #report_summary + when any offenses are detected + reports all detected offenses for all failed files + when no offenses are detected + does not report offenses + #file_finished + when no offenses are detected + calls #report_as_with_mark + when any offenses are detected + calls #report_as_with_mark + #report_file_as_mark + when different severity offenses are detected + prints highest level mark + when a refactor severity offense is detected + prints "R" + when no offenses are detected + prints "." + when a refactor convention offense is detected + prints "C" -RuboCop::Cop::Style::MultilineMemoization - EnforcedStyle: braces - with a multiline memoization - without a `begin` and `end` block - allows with another block on the first line - allows with another block on the following line - allows with a conditional on the first line - allows with a conditional on the following line - with a single line memoization - allows expression on first line - allows expression on the following line - with a multiline memoization - without braces - when the expression is wrapped in `begin` and `end` keywords - registers an offense for begin...end block on first line - registers an offense for begin...end block on following line - EnforcedStyle: keyword - with a multiline memoization - without a `begin` and `end` block - when the expression is wrapped in parentheses - registers an offense with multiline expression - registers an offense when expression starts on following line - registers an offense when expression starts on first line - with a single line memoization - allows expression on the following line - allows expression on first line - with a multiline memoization - without a `begin` and `end` block - allows with a conditional on the following line - allows with another block on the first line - allows with a conditional on the first line - allows with another block on the following line +RuboCop::TargetRuby + when TargetRubyVersion is not set + when .tool-versions is present + when .tool-versions does not contain a ruby version + uses the default ruby version + when .tool-versions contains a ruby version + reads it to determine the target ruby version + does not read Gemfile.lock, gems.locked + when .ruby-version is present + does not read .tool-versions, Gemfile.lock or gems.locked + when .ruby-version contains a version prefixed by "ruby-" + correctly determines the target ruby version + when the MRI version contains multiple digits + reads it to determine the target ruby version + when .ruby-version contains a JRuby version + uses the default target ruby version + when .ruby-version contains an MRI version + reads it to determine the target ruby version + when .ruby-version contains a Rbx version + uses the default target ruby version + when .ruby-version contains "system" version + uses the default target ruby version + when .ruby-version is not in a parent directory + when gems.locked is in a parent directory + does + when Gemfile.lock is in a parent directory + does + when .ruby-version is not present + when bundler lock files are not present + uses the default target ruby version + and gems.locked exists + uses the default Ruby when rbx is in gems.locked + uses the default Ruby when Ruby is not in gems.locked + uses MRI Ruby version when it is present in gems.locked + uses the default Ruby when jruby is in gems.locked + uses MRI Ruby version when it has multiple digits + and Gemfile.lock exists + uses MRI Ruby version when it has multiple digits + uses the default Ruby when Ruby is not in Gemfile.lock + uses the default Ruby when jruby is in Gemfile.lock + uses MRI Ruby version when it is present in Gemfile.lock + uses the default Ruby when rbx is in Gemfile.lock + gemspec file + when file contains `required_ruby_version` as a requirement + sets first known ruby version that satisfies requirement + sets target_ruby from required_ruby_version from inclusive requirement range + when file contains `required_ruby_version` as a string + sets target_ruby from approximate version + sets target_ruby from exclusive range + sets target_ruby from inclusive range + when file does not contain `required_ruby_version` + sets default target_ruby + when file contains `required_ruby_version` as an array + sets target_ruby from required_ruby_version with many requirements + sets target_ruby to the minimal version satisfying the requirements + when .ruby-version is in a parent directory + reads it to determine the target ruby version + when TargetRubyVersion is set + does not read Gemfile.lock or gems.locked + uses TargetRubyVersion + does not read .ruby-version -RuboCop::Cop::Style::NestedTernaryOperator - registers an offense and corrects for a nested ternary operator expression - accepts a non-nested ternary operator within an if - can handle multiple nested ternaries - registers an offense and corrects for a nested ternary operator expression with no parentheses on the outside - registers an offense and corrects for a nested ternary operator expression with block +RuboCop::Cop::Lint::EmptyInterpolation + registers an offense and corrects #{ } in interpolation + accepts non-empty interpolation + finds interpolations in string-like contexts + registers an offense and corrects #{} in interpolation -RuboCop::Cop::Style::StructInheritance - registers an offense when extending instance of `Struct` when there is a comment before class declaration - registers an offense when extending instance of Struct without `do` ... `end` and class body is empty - registers an offense when extending instance of ::Struct with do ... end - accepts assignment to ::Struct.new - registers an offense when extending instance of Struct without `do` ... `end` and class body is empty and single line definition - accepts assignment to block form of Struct.new - registers an offense when extending instance of ::Struct - registers an offense when extending instance of Struct - registers an offense when extending instance of Struct with do ... end - accepts assignment to Struct.new - accepts extending DelegateClass - accepts plain class +RuboCop::Cop::Style::ReturnNil + when enforced style is `return_nil` + registers an offense for return + does not register an offense for returning others + when enforced style is `return` + does not register an offense for return nil from iterators + registers an offense for return nil + does not register an offense for returning others -RuboCop::Cop::InternalAffairs::MethodNameEndWith - registers an offense if there is potentially usage of `assignment_method?` - registers offense if there is potentially usage of `bang_method?` with safe navigation operator - does not register offense if argument for end_with? is some other string - registers an offense if `method_name` is a variable and there is potentially usage of `assignment_method?` - registers offense if there is potentially usage of `predicate_method?` - registers offense if there is potentially usage of `bang_method?` - Ruby >= 2.7 - registers an offense if method_name is symbol with safe navigation operator - registers offense if argument for Symbol#end_with? is '?' with safe navigation operator - does not register offense if argument for Symbol#end_with? is some other string - registers an offense if method_name is symbol - registers offense if argument for Symbol#end_with? is '!' - registers offense if argument for Symbol#end_with? is '?' - registers offense if argument for Symbol#end_with? is '!' with safe navigation operator +RuboCop::Cop::Style::EvalWithLocation + accepts `eval` with a heredoc, a filename and `__LINE__ + 1` + registers an offense when using `instance_eval` with improper arguments + accepts `eval` with a string, a filename and `__LINE__` + registers an offense when using `#eval` with a heredoc and an incorrect line number + registers an offense when using `#eval` without any arguments + registers an offense when using `Kernel.eval` without any arguments + accepts `eval` with a string, a filename and `__LINE__` on a new line + registers an offense when using `#eval` with `binding` only + registers an offense when using `class_eval` with improper arguments + registers an offense when using `#eval` without lineno + registers an offense when using `#instance_eval` without any arguments + registers an offense when using `::Kernel.eval` without any arguments + registers an offense when using `#module_eval` without any arguments + does not register an offense when using eval with block argument + accepts `eval` with a code that is a variable + does not register an offense if `eval` is called on another object + registers an offense when using `module_eval` with improper arguments + registers an offense when using `#instance_eval` with a string argument in parentheses + registers an offense when using `eval` with improper arguments + registers an offense when using `#class_eval` without any arguments + registers an offense when using `#class_eval` with an incorrect lineno + registers an offense when using correct file argument but incorrect line + registers an offense when using `#eval` with a string on a new line + registers an offense when using `#eval` with an incorrect line number RuboCop::Cop::Style::Alias + when EnforcedStyle is prefer_alias_method + registers an offense for alias with bareword args + does not register an offense for alias with gvars + does not register an offense for alias_method + registers an offense for alias with symbol args + does not register an offense for alias in an instance_eval block when EnforcedStyle is prefer_alias - does not register an offense for alias_method with non-literal constant argument - does not register an offense for alias_method in self.method def - registers an offense for alias_method in a module block + registers an offense for alias_method in a class block + registers an offense for alias with symbol args does not register an offense for alias in an instance_eval block + does not register an offense for alias_method in a block does not register an offense for alias_method in a method def - registers an offense for alias_method in a class block - does not register an offense for alias with bareword args + does not register an offense for alias_method with non-literal constant argument does not register an offense for alias_method with explicit receiver + does not register an offense for alias with bareword args does not register an offense for alias_method with non-literal method call argument - registers an offense for alias with symbol args + does not register an offense for alias_method in self.method def + registers an offense for alias_method in a module block registers an offense for alias_method at the top level - does not register an offense for alias_method in a block - when EnforcedStyle is prefer_alias_method - registers an offense for alias with symbol args - registers an offense for alias with bareword args - does not register an offense for alias in an instance_eval block - does not register an offense for alias_method - does not register an offense for alias with gvars - -RuboCop::Cop::Lint::UselessRuby2Keywords - when `ruby2_keywords` is given a symbol - does not register an offense when there is no `def` - does not register an offense when the `def` is at a different depth - registers an offense for an unnecessary `ruby2_keywords` - does not register an offense for an allowed def - with a dynamically defined method - does not register an offense for an allowed `ruby2_keywords` - registers an offense for an unnecessary `ruby2_keywords` - does not register an offense when the method has a `restarg` and a `shadowarg` - registers an offense when the method has a `shadowarg` - registers an offense for a numblock - when `ruby2_keywords` is given a `def` node - does not register an offense for a method with a `restarg` other optional args - registers an offense for a method with only keyword args - registers an offense for a method with a `restarg` and keyword args - registers an offense for a method with only positional args - registers an offense for a method with only `kwrestarg` - does not register an offense for a method with a `restarg` other positional args - registers an offense for a method without arguments - does not register an offense for a method with a `restarg` and no `kwrestarg` - registers an offense for a method with a `restarg` and `kwrestarg` - registers an offense for a method with a `restarg` and `kwoptarg` - does not register an offense for a method with a `restarg` and `blockarg` - -RuboCop::Cop::InternalAffairs::NumblockHandler - does not register an offense for cops with on_numblock method - registers an offense for cops with forgotten numblock handlers - does not register an offense for cops with on_numblock alias_method - does not register an offense for cops with on_numblock alias - -RuboCop::Cop::Naming::MethodName - accepts for non-ascii characters - when configured for snake_case - registers an offense for mixed snake case and camel case in attr. - registers an offense for singleton upper case method without corresponding class - accepts class emitter method in a class - accepts unary operator definitions - accepts snake case in names - accepts class emitter method in a module - registers an offense for camel case methods names in attr. - registers an offense for capitalized camel case - registers an offense for mixed snake case and camel case - registers an offense for opposite + correct - accepts class emitter method in a module, even when it is defined inside another method - registers an offense for camel case method names in attr. - registers an offense for mixed snake case and camel case in attr. - registers an offense for camel case in singleton method name - accepts one line methods - registers an offense for capitalized camel case name in attr. - accepts operator definitions - accepts snake case in attr. - registers an offense for singleton camelCase method within class - registers an offense for camel case in instance method name - accepts class emitter method in a class, even when it is defined inside another method - when specifying `AllowedPatterns` - does not register an offense for snake case method name matching `AllowedPatterns` - does not register an offense for camel case method name in attr. - does not register an offense for snake case method name in attr. - does not register an offense for camel case method name matching `AllowedPatterns` - when configured for camelCase - registers an offense for capitalized camel case - accepts unary operator definitions - accepts camel case in singleton method name - registers an offense for snake case name in attr. - registers an offense for snake case in names - accepts camel case in instance method name - accepts camel case names in attr. - registers an offense for correct + opposite - accepts class emitter method in a class - registers an offense for camel case methods names in attr. - registers an offense for mixed snake case and camel case in attr. - registers an offense for singleton snake_case method within class - registers an offense for mixed snake case and camel case in attr. - accepts class emitter method in a module, even when it is defined inside another method - accepts class emitter method in a module - registers an offense for singleton upper case method without corresponding class - accepts operator definitions - registers an offense for mixed snake case and camel case - accepts class emitter method in a class, even when it is defined inside another method - accepts one line methods - registers an offense for capitalized camel case name in attr. - when specifying `AllowedPatterns` - does not register an offense for snake case method name matching `AllowedPatterns` - does not register an offense for camel case method name matching `AllowedPatterns` - does not register an offense for camel case method name in attr. - does not register an offense for snake case method name in attr. - -RuboCop::Cop::VariableForce::Scope - #name - when the scope is instance method definition - returns the method name - when the scope is singleton method definition - returns the method name - #body_node - when the scope is top level - returns the body node - when the scope is singleton class - returns the body node - when the scope is class - returns the body node - when the scope is module - returns the body node - when the scope is instance method - returns the body node - when the scope is singleton method - returns the body node - when the scope is block - returns the body node - .new - when begin node is passed - accepts that as top level scope - when lvasgn node is passed - accepts that as top level scope - #include? - with child node the scope includes - is expected to equal true - with node of the scope itself - is expected to equal false - with descendant node the scope does not include - is expected to equal false - with ancestor node the scope does not include - is expected to equal false - with child node the scope does not include - is expected to equal false - #each_node - inner scope boundary handling - when there's a singleton method definition - yields only the defs node and the method host node - when there's a method invocation with block - yields only the block node and the child send node - outer scope boundary handling - when the scope is instance method - yields the argument and the body nodes - when the scope is singleton method - yields the argument and the body nodes - when the scope is class - yields the body nodes - when the scope is module - yields the body nodes - when the scope is singleton class - yields the body nodes - when the scope is block - yields the argument and the body nodes - when the scope is top level - yields the body nodes - -RuboCop::Cop::Security::YAMLLoad - does not register an offense for YAML.dump - registers an offense and corrects a fully qualified ::YAML.load - does not register an offense for YAML.load under a different namespace - registers an offense and corrects load with a literal string - Ruby >= 3.1 - does not register an offense and corrects a fully qualified `::YAML.load` - does not register an offense and corrects load with a literal string - -RuboCop::Config - #for_department - always returns the department's config - accepts a Symbol - #check - when a deprecated configuration is detected - prints a warning message for the loaded path - #for_badge - takes into account the department - works if department has no config - #patterns_to_include - when config file has AllCops => Include key - returns the Include value - #file_to_exclude? - when the passed path matches any of patterns to exclude - returns true - when the passed path does not match any of patterns to exclude - returns false - #make_excludes_absolute - when config is in root directory - generates valid absolute directory - when config is in subdirectory - generates valid absolute directory - whether the cop is enabled - when an entire cop department is disabled - but an individual cop is enabled - the cop setting overrides the department - when configuration has no mention of a cop - enables the cop that is not mentioned - when all cops are disabled by default - disables the cop that is not mentioned - when all cops are explicitly enabled by default - enables the cop that is not mentioned - when an entire cop department is enabled - but an individual cop is disabled - still disables the cop - when an nested cop department is disabled - but an individual cop is enabled - the cop setting overrides the department - and an individual cop is not specified - the cop setting overrides the department - when a cop has configuration but no explicit Enabled setting - enables the cop by default - #patterns_to_exclude - when config file has AllCops => Exclude key - returns the Exclude value - #file_to_include? - when the passed path matches any of patterns to include - returns true - when the passed path does not match any of patterns to include - returns false - #deprecation_check - when there is AllCops configuration - if there are is an Includes key - yields - if there are is an Excludes key - yields - if there are no Excludes or Includes keys - does not yield - when there is no AllCops configuration - does not yield - #validate - when all cops are both Enabled and Disabled by default - raises validation error - when the configuration includes multiple valid enforced styles and one invalid style - raises validation error - when the configuration includes Lint/Syntax cop - when the configuration matches the default - does not raise validation error - when the configuration does not match the default - raises validation error - conflicting Safe settings - when the configuration includes an unsafe cop without a declaration of its autocorrection - does not raise validation error - when the configuration includes an unsafe cop that is explicitly declared to have a safe autocorrection - raises validation error - when the configuration includes any unrecognized cop name and given `--ignore-unrecognized-cops` option - there are no unrecognized cops - does not print any warnings - there is unrecognized cop - prints a warning about the cop - when the configuration is in the base RuboCop config folder - is not validated - when the configuration includes an invalid enforced style - raises validation error - when the configuration includes any unrecognized parameter - prints a warning message - when the configuration includes a valid enforced style - does not raise validation error - when the configuration includes any common parameter - does not raise validation error - when the configuration includes an invalid EnforcedStyle - raises validation error - when the configuration includes the obsolete Style/WhileUntilModifier: MaxLineLength parameter - raises validation error - when the empty section is AllCops - raises validation error - when the configuration includes an obsolete EnforcedStyle parameter - raises validation error - when the configuration includes multiple invalid enforced styles - raises validation error - when the configuration includes obsolete parameters and cops - raises validation error - when the configuration includes an obsolete parameter - raises validation error - when the configuration includes an empty section - raises validation error - when the configuration includes an obsolete cop - raises validation error - when the configuration includes the obsolete Style/IfUnlessModifier: MaxLineLength parameter - raises validation error - when the configuration includes any unrecognized cop name - raises an validation error - when the configuration includes a valid EnforcedStyle - does not raise validation error - when the configuration includes multiple valid enforced styles - does not raise validation error - when the configuration includes multiple but config does not allow - raises validation error - #possibly_include_hidden? - returns true when Include config only includes regular paths - returns true when Include config includes a toplevel dotfile - returns true when Include config includes a regex - returns true when Include config includes a dotfile in a path - #allowed_camel_case_file? - when the passed path is a gemspec - is expected to equal true - when the passed path matches allowed camel case patterns to include - is expected to equal true - when the passed path does not match allowed camel case patterns to include - is expected to equal false - -RuboCop::Cop::Naming::HeredocDelimiterCase - when enforced style is lowercase - with an interpolated heredoc - registers an offense and corrects with an uppercase delimiter - registers an offense and corrects with a camel case delimiter - does not register an offense with a lowercase delimiter - with a squiggly heredoc - registers an offense and corrects with an uppercase delimiter - registers an offense and corrects with a camel case delimiter - does not register an offense with a lowercase delimiter - with a non-interpolated heredoc - does not register an offense with a lowercase delimiter - registers an offense and corrects with an uppercase delimiter - registers an offense and corrects with a camel case delimiter - when enforced style is uppercase - with a squiggly heredoc - does not register an offense with an uppercase delimiter - registers an offense and corrects with a lowercase delimiter - registers an offense and corrects with a camel case delimiter - with an interpolated heredoc - does not register an offense with an uppercase delimiter - registers an offense and corrects with a lowercase delimiter - registers an offense with a camel case delimiter - with a non-interpolated heredoc - when using single quoted delimiters - does not register an offense with an uppercase delimiter - registers an offense and corrects with a lowercase delimiter - registers an offense and corrects with a camel case delimiter - when using back tick delimiters - registers an offense and corrects with a lowercase delimiter - registers an offense and corrects with a camel case delimiter - does not register an offense with an uppercase delimiter - when using double quoted delimiters - does not register an offense with an uppercase delimiter - registers an offense and corrects with a camel case delimiter - registers an offense and corrects with a lowercase delimiter - when using non-word delimiters - does not register an offense - -RuboCop::Cop::Style::RedundantException - reports an offense for a raise with ::RuntimeError and () - accepts a fail with RuntimeError if it does not have 2 args - accepts rescue w/ non redundant error - reports an offense for a raise with ::RuntimeError.new - reports an offense for a fail with RuntimeError and () - accepts a raise with ::RuntimeError if it does not have 2 args - reports an offense for a raise with ::RuntimeError.new - reports an offense for a fail with ::RuntimeError - reports an offense for a raise with RuntimeError.new - accepts a raise with RuntimeError if it does not have 2 args - accepts rescue w/ non redundant error - accepts rescue w/ non redundant error - reports an offense for a fail with ::RuntimeError.new - reports an offense for a fail with RuntimeError.new - reports an offense for a fail with ::RuntimeError.new - reports an offense for a fail with ::RuntimeError and () - reports an offense for a raise with RuntimeError.new - reports an offense for a raise with ::RuntimeError - reports an offense for a fail with RuntimeError - accepts a fail with ::RuntimeError if it does not have 2 args - accepts rescue w/ non redundant error - reports an offense for a raise with RuntimeError - reports an offense for a raise with RuntimeError and () - reports an offense for a fail with RuntimeError.new - -RuboCop::Cop::Layout::SpaceBeforeBrackets - does not register an offense when using array literal argument without parentheses - does not register an offense when assigning an array - does not register an offense when using percent array literal argument without parentheses - when referencing - does not register an offense when not using space between method call and left brackets - does not register an offense when using multiple arguments - registers an offense and corrects when using space between cvar receiver and left brackets - does not register an offense when call desugared `Hash#[]` to cvar receiver - registers an offense and corrects when using space between ivar receiver and left brackets - does not register an offense when call desugared `Hash#[]` to ivar receiver - does not register an offense when not using space between variable receiver and left brackets - does not register an offense when array literal argument is enclosed in parentheses - does not register an offense when without receiver - registers an offense and corrects when using space between lvar receiver and left brackets - does not register an offense when it is used as a method argument - registers an offense and corrects when using space between gvar receiver and left brackets - does not register an offense when call desugared `Hash#[]` to lvar receiver - does not register an offense when using space between method call and left brackets - when assigning - does not register an offense when not using space between receiver and left brackets - registers an offense and corrects when using space between receiver and left brackets - does not register an offense when space is used in left bracket - does not register an offense when multiple spaces are inserted inside the left bracket - -RuboCop::Cop::Layout::SpaceInsideReferenceBrackets - when EnforcedStyle is no_space - registers an offense and corrects third ref brackets with trailing whitespace - registers an offense and corrects when a reference bracket with a trailing whitespace is assigned by another reference bracket - registers an offense and corrects third ref brackets with leading whitespace - register and correct multiple offenses for multiple sets of ref brackets - does not register offense for reference brackets with no spaces - registers an offense and corrects when a reference bracket is assigned by another reference bracket with trailing whitespace - registers an offense and corrects second ref brackets with leading whitespace - accepts square brackets as method name - registers an offense and corrects outer ref brackets - registers multiple offenses and corrects multiple sets of ref brackets - does not register offense for array literals - registers an offense and corrects second ref brackets with trailing whitespace - registers multiple offenses and corrects one set of ref brackets - registers an offense and corrects ref brackets with leading whitespace - does not register offense for ref bcts with no spaces that assign - accepts extra spacing in array brackets - does not register offense for non-empty brackets with newline inside - registers an offense and corrects ref brackets with trailing whitespace - registers an offense and corrects when a reference bracket with a leading whitespace is assigned by another reference bracket - accepts an array as a reference object - accepts square brackets called with method call syntax - with space inside empty brackets not allowed - registers an offense and corrects empty brackets with newline inside - registers an offense and corrects empty brackets with 1 space inside - accepts empty brackets with no space inside - registers an offense and corrects empty brackets with multiple spaces inside - with space inside empty braces allowed - registers offense and corrects empty brackets with no space inside - registers offense and corrects empty brackets with newline inside - accepts empty brackets with space inside - registers offense and corrects empty brackets with more than one space inside - when EnforcedStyle is space - accepts square brackets as method name - registers an offense and corrects third ref brackets with no leading whitespace - registers an offense and corrects ref brackets with no leading whitespace - does not register offense for reference brackets with spaces - registers an offense and corrects when a reference bracket with no trailing whitespace is assigned by another reference bracket - registers an offense and correct third ref brackets with no trailing whitespace - registers an offense and corrects when a reference bracket with no leading whitespace is assigned by another reference bracket - registers and corrects multiple offenses for multiple sets of ref brackets - registers an offense and corrects second ref brackets with no leading whitespace - registers an offense and corrects when a reference bracket is assigned by another reference bracket with no trailing whitespace - does not register offense for array literals - registers and corrects multiple offenses in one set of ref brackets - accepts square brackets called with method call syntax - registers an offense and corrects ref brackets with no trailing whitespace - accepts spaces in array brackets - accepts an array as a reference object - registers an offense and corrects second ref brackets with no trailing whitespace - does not register offense for ref bcts with spaces that assign - -RuboCop::Cop::Style::MultilineWhenThen - doesn't register an offense for singleline when statement with then - registers an offense for multiline (one line in a body) when statement with then - doesn't register an offense for multiline when statement without then - doesn't register an offense for empty when statement without then - autocorrects when the body of `when` branch starts with `then` - registers an offense when one line for multiple candidate values of `when` - doesn't register an offense for multiline when statementwith then followed by other lines - does not register an offense when line break for multiple candidate values of `when` - registers an offense for multiline (two lines in a body) when statement with then - registers an offense for empty when statement with then - doesn't register an offense when `then` required for a body of `when` is used - does not register an offense for hash when statement with then - does not register an offense for array when statement with then - -RuboCop::Cop::Lint::EmptyInPattern - when a `in` body is present - accepts `case` with `in` ... `then` statements - accepts `case` with `in` ... `then` statements and else clause - accepts `case` with `in` bodies - accepts `case` with `in` bodies and `else` clause - when `AllowComments: false` - registers an offense for empty `in` body with a comment - when a `in` body is missing - registers an offense for missing `in` body followed by `else` - registers an offense for missing `in` body with a comment - registers an offense for missing `in` ... then `body` followed by `else` - registers an offense for missing `in` ... `then` body - registers an offense for missing `in` body with a comment followed by `else` - registers an offense for a missing `in` body - when `AllowComments: true` - registers an offense for empty `in` when comment is in another branch - accepts an empty `in` body with a comment -RuboCop::Cop::Lint::NumberedParameterAssignment - registers an offense when using `_10` lvar - does not register an offense when index assignment - registers an offense when using `_0` lvar - does not register an offense when using non numbered parameter - when Ruby 2.7 or lower - registers an offense when using `_6` numbered parameter - registers an offense when using `_8` numbered parameter - registers an offense when using `_7` numbered parameter - registers an offense when using `_4` numbered parameter - registers an offense when using `_9` numbered parameter - registers an offense when using `_5` numbered parameter - registers an offense when using `_1` numbered parameter - registers an offense when using `_3` numbered parameter - registers an offense when using `_2` numbered parameter +RuboCop::Cop::Style::NumericLiterals + registers an offense for an integer with misplaced underscore + autocorrects negative numbers + autocorrects numeric literal with exponent and dot + autocorrects negative floating-point numbers + accepts long numbers with underscore + ignores non-decimal literals + registers an offense for a long undelimited integer + registers an offense for a float with a long undelimited integer part + handles numeric literal with exponent + autocorrects numbers with spaces between leading minus and numbers + does not count a leading minus sign as a digit + accepts integers with less than three places at the end + accepts a short integer without underscore + accepts short numbers without underscore + autocorrects numeric literal with exponent (large E) and dot + when `'3000'` is specified for `AllowedNumbers` + does not register an offense + registers an offense + when `3000` is specified for `AllowedNumbers` + does not register an offense + registers an offense + for --auto-gen-config + when the number is only digits + detects right value of MinDigits based on the longest number + sets the right value if one is disabled inline + with separators + does not disable the cop if the line is disabled + disables the cop + strict + registers an offense for an integer with misplaced underscore + AllowedPatterns + does not register an offense for numbers that exactly match the pattern + registers an offense for numbers that do not exactly match the pattern + corrects by inserting underscores every 3 digits + AllowedPatterns with repetition + does not register an offense for numbers that match the pattern -RuboCop::Cop::Lint::UnreachableLoop - does not register an offense when using `return do_something(value) || next` in a loop - handles inner loops - registers an offense when using `return do_something(value) || break` in a loop - does not register an offense when branch includes continue statement preceding break statement - does not register an offense when using `return do_something(value) || redo` in a loop - with AllowedPatterns - with a non ignored method call - registers an offense +RuboCop::Cop::Layout::IndentationWidth + with Width set to 2 + with while/until + registers an offense for bad indentation of an until body + registers an offense for bad indentation of begin/end/while + accepts an empty while + registers an offense for bad indentation of a while body + with case + registers an offense for bad indentation in a case/else body + accepts aligned values in when clause + accepts case/when/else with then beginning a line + accepts case/when/else laid out as a table + accepts correctly indented case/when/else + accepts indented when/else plus indented body + registers an offense for bad indentation in a case/when body + with class + leaves body unchanged if the first body line is on the same line with an opening of singleton class + leaves body unchanged if the first body line is on the same line with class keyword + registers an offense for bad indentation of a class body + accepts an empty class body + with access modifier + registers an offense and corrects for bad modifier indentation before good method definition + registers an offense for bad indentation of sections + when consistency style is normal + registers offenses for indented_internal_methods indentation + accepts indented public, protected, and private + when consistency style is indented_internal_methods + registers an offense for normal non-indented internal methods indentation + registers an offense for normal non-indented internal methods indentation when defined in a singleton class + when consistency style is outdent + accepts access modifier is outdent + with unless + accepts an empty unless + registers an offense for bad indentation of an unless body + with def/defs + when end is aligned with start of line + registers an offense for bad indentation of a def body + registers an offense for bad indentation of a defs body + accepts an empty def body + with an assignment + accepts an empty defs body + when multiple modifiers and def are on the same line + registers an offense for bad indentation of a def body + registers an offense for bad indentation of a defs body + accepts a correctly aligned body + when multiple modifiers are used in a block anda method call is made at end of the block + accepts a correctly aligned body + registers an offense for bad indentation of a def + registers an offense for bad indentation of a def body + when modifier and def are on the same line + registers an offense for bad indentation of a def body + accepts a correctly aligned body + registers an offense for bad indentation of a defs body + when end is aligned with def + accepts an empty defs body + accepts an empty def body + registers an offense for bad indentation of a def body + registers an offense for bad indentation of a defs body + with an assignment + when modifier and def are on the same line + registers an offense for bad indentation of a defs body + registers an offense for bad indentation of a def body + accepts a correctly aligned body + with begin/rescue/else/ensure/end + registers an offense for bad indentation of bodies + with if statement + leaves rescue ; end unchanged + registers and corrects on offense for bad indentation + accepts an if/else branches with rescue clauses + registers an offense for bad indentation of an elsif body + does not correct in scopes that contain block comments + handles lines with only whitespace + accepts a correctly aligned if/elsif/else/end as a method argument + accepts a correctly aligned if/elsif/else/end + does not indent heredoc strings + registers an offense for bad indentation of an else body when if and elsif body contains no code + registers an offense for bad indentation of an else body when if body contains no code + does not raise any error with empty braces + accepts `rescue`/`ensure` after an empty body + registers offense for bad indentation of ternary inside else + accepts `ensure` after an empty body + accepts `rescue`/`ensure` after an empty def + accepts `ensure` after an empty def + leaves block unchanged if block end is not on its own line + accepts `rescue` after an empty body + indents parenthesized expressions + accepts if/elsif/else/end laid out as a table + accepts if/then/else/end laid out as another table + accepts an empty if + accepts indentation after if on new line after assignment + accepts `rescue` after an empty def + accepts a one line if statement + registers an offense for bad indentation of an if body + registers offense for bad indentation of modifier if in else + registers an offense for bad indentation of an else body + with assignment + when alignment style is start_of_line + and end is aligned randomly + registers an offense for a while + registers an offense for an until + registers an offense for an if + and end is aligned with keyword + registers an offense for an if + registers an offense for an if with setter + accepts an if/else in assignment on next line + registers an offense for an if with element assignment + registers an offense for an until + registers an offense for a while + and end is aligned with variable + accepts an if/else with chaining after the end + accepts an if/else with chaining with a block after the end + accepts an if with end aligned with setter + accepts an if with end aligned with variable + accepts an if/else + accepts an if with end aligned with element assignment + when alignment style is variable + and end is aligned randomly + registers an offense for an until + registers an offense for a while + registers an offense for an if + and end is aligned with variable + accepts an if with end aligned with setter + accepts an if/else with chaining with a block after the end + accepts an if/else with chaining after the end + accepts an if with end aligned with element assignment + accepts an if/else + accepts an if with end aligned with variable + and end is aligned with keyword + registers an offense for an until + registers an offense for an if + registers an offense for a while + registers an offense for an if with setter + registers an offense for an if with element assignment + accepts an if/else in assignment on next line + when alignment style is keyword + and end is aligned with variable + registers an offense for an if + registers an offense for a while + registers and corrects bad indentation + and end is aligned with keyword + accepts a while in assignment + accepts an until in assignment + accepts an if in assignment + accepts an if/else in assignment + accepts an if/else in assignment on next line + with def/rescue/end + registers an offense for bad indentation of bodies + registers an offense for bad indent of defs bodies with a modifier + with module + leaves body unchanged if the first body line is on the same line with module keyword + when consistency style is indented_internal_methods + registers an offense for bad indentation of a module body + accepts normal non-indented internal methods of module functions + when consistency style is normal + accepts an empty module body + registers an offense for bad indentation of a module body + with block + accepts a correctly indented block body + registers an offense for bad indentation of a {} body + registers an offense for bad indentation of `do` ... `ensure` ... `end` block + does not register an offense for good indentation of `do` ... `ensure` ... `end` block + accepts an empty block body + registers an offense for bad indentation of a do/end body + accepts badly indented code if block end is not on separate line Ruby 2.7 - registers an offense - with a ignored method call - does not register an offense - without preceding continue statements - does not register an offense when using `case` without `else` - does not register an offense when using `if` without `else` - registers an offense when using `break` - does not register an offense when using `case-when-else` and not all branches are breaking - registers an offense when using `if-else` with all break branches - registers an offense when using `case-when-else` with all break branches - does not register an offense when using `if-elsif-else` and not all branches are breaking - with preceding continue statements - does not register an offense when using `if-else` with all break branches - does not register an offense when using `case-when-else` with all break branches - does not register an offense when using `break` - Ruby 2.7 - registers an offense when using `return do_something(value) || break` in a loop - with an enumerator method - in the middle of a method chain - does not register an offense - not chained - registers an offense - as the last item in a method chain - registers an offense - -RuboCop::Cop::Style::HashLikeCase - MinBranchesCount: 2 - does not register an offense when using `case-when` with non-literals in conditions - does not register an offense when using `case-when` with non-literal bodies - registers an offense when using `case-when` with string conditions and literal bodies of the same type - registers an offense when using `case-when` with symbol conditions and literal bodies of the same type - does not register an offense when `case` has an `else` branch - does not register an offense when using `case-when` with literal bodies of different types - does not register an offense when using `case-when` with literals of different types as conditions - MinBranchesCount: 3 - does not register an offense when branches count is less than required - -RuboCop::Cop::Lint::DuplicateRequire - registers and corrects an offense when duplicate `require` is detected - does not register an offense when calling user-defined `require` method - does not register an offense when same feature argument but different require method - registers and corrects an offense when duplicate `require_relative` is detected - registers and corrects an offense for multiple duplicate requires - registers and corrects an offense when duplicate `require` through `Kernel` is detected - does not register an offense when there are no duplicate `require`s - registers and corrects an offense for duplicate non top-level requires - registers and corrects an offense when duplicate requires are interleaved with some other code - does not register an offense when using single `require` - -RuboCop::Cop::Lint::ConstantDefinitionInBlock - does not register an offense for a top-level module - registers an offense for a module defined within a block followed by another statement - does not register an offense for a constant with an explicit top-level scope followed by another statement - registers an offense for a class defined within a block - does not register an offense for a constant with an explicit top-level scope - does not register an offense for a constant with an explicit self scope followed by another statement - registers an offense for a constant defined within a block followed by another statement - does not register an offense for a constant with an explicit self scope - does not register an offense for a top-level class followed by another statement - does not register an offense for a top-level constant followed by another statement - does not register an offense for a top-level constant - registers an offense for a module defined within a block - registers an offense for a class defined within a block followed by another statement - does not register an offense for a top-level class - registers an offense for a constant defined within a block - does not register an offense for a top-level module followed by another statement - when `AllowedMethods: [enums]` - does not register an offense for a module defined within a block of `enums` method - does not register an offense for a class defined within a block of `enums` method - does not register an offense for a casign used within a block of `enums` method - when `AllowedMethods: []` - registers an offense for a class defined within a block of `enums` method - registers an offense for a module defined within a block of `enums` method - registers an offense for a casign used within a block of `enums` method - -RuboCop::Cop::Lint::UnusedBlockArgument - inspection - when a block have a block local variable - and the variable is used - does not register offense - and the variable is unused - registers an offense - when a block takes single argument - and the method call is `define_method` - registers an offense - and the argument is unused - registers an offense and suggests omitting that - in a method calling `binding` without arguments - accepts all arguments - inside a method definition - registers offenses - when a lambda block takes arguments - and an argument is unused - registers an offense - and all the arguments are unused - registers offenses and suggests using a proc - when a variable is not used - does not care - when an optional keyword argument is unused - when the method call is `define_method` - registers an offense - when AllowUnusedKeywordArguments set - does not care - when the method call is not `define_method` - registers an offense - when AllowUnusedKeywordArguments set - does not care - when a method argument is not used - does not care - when an underscore-prefixed block argument is not used - accepts - in a method calling `binding` with arguments - when a method argument is unused - registers an offense - with an empty block - when not configured to ignore empty blocks - registers an offense - when configured to ignore empty blocks - does not register an offense - when a block takes multiple arguments - and all the arguments are unused - registers offenses and suggests omitting them - and unused arguments span multiple lines - registers offenses and suggests omitting them - and an argument with default value is unused - registers an offense and preserves default value - and one argument is assigned to another, whilst other's value is not used - registers an offense - and all arguments are used - accepts - and an argument is unused - registers an offense - and a splat argument is unused - registers an offense and preserves splat - and arguments are swap-assigned - accepts - when IgnoreEmptyBlocks config parameter is set - registers an offense for a non-empty block with multiple unused args - accepts an empty block with a single unused parameter - registers an offense for a non-empty block with an unused parameter - accepts an empty block with multiple unused parameters + registers an offense for bad indentation of a do-end body + registers an offense for bad indentation of a {} body + when using safe navigation operator + registers an offense for bad indentation of a {} body + registers an offense for an if with setter + when consistency style is indented_internal_methods + registers an offense for bad indentation in a do/end body + with for + registers an offense for bad indentation of a for body + accepts an empty for + with case match + accepts aligned values in `in` clause + accepts case/in/else with then beginning a line + registers an offense for bad indentation in a case/in body + accepts aligned value in `in` clause and `else` is empty + accepts correctly indented case/in/else + accepts case/in/else laid out as a table + registers an offense for bad indentation in a case/else body + accepts indented in/else plus indented body + with Width set to 4 + registers and corrects offense for bad indentation + with ignored patterns set + accepts unindented lines for those keywords + for a file with byte order mark + accepts correctly indented method definition + with if statement + registers an offense for bad indentation of an if body -RuboCop::Cop::Layout::ClosingParenthesisIndentation - accepts begin nodes that are not grouped expressions - for grouped expressions - with line break before 1st operand - accepts a correctly aligned ) - registers an offense for misaligned ) - with no line break before 1st operand - accepts a correctly aligned ) - registers an offense for misaligned ) - accepts ) that does not begin its line - for method chains - can handle multiple chains with differing breaks - registers an offense and corrects method chains - when using safe navigation operator - registers an offense and corrects misaligned ) - for method assignments with indented parameters - with no line break before 1st parameter - can handle individual arguments that are broken over lines - can handle inner method calls - accepts a correctly indented ) - registers an offense for misaligned ) - can handle indentation up against the left edge - can handle hash arguments that are not broken over lines - accepts a correctly aligned ) - with line break before 1st parameter - registers an offense for misaligned ) - accepts a correctly aligned ) - without arguments - can handle indentation up against the left edge - can handle indentation up against the method - accepts empty () - accepts a correctly aligned ) against ( - registers an offense for misaligned ) - for method calls - without arguments - accepts a correctly aligned ) against ( - accepts empty () - can handle indentation up against the left edge - with first multiline arg on new line - accepts ) on the same level as ( with second arg on new line - accepts ) on the same level as ( with args on same line - with line break before 1st parameter - accepts a correctly aligned ) - registers an offense for misaligned ) - with no line break before 1st parameter - accepts a correctly indented ) inside a block - registers an offense for misaligned ) - accepts a correctly indented ) - accepts a correctly aligned ) - registers an offense and corrects misindented ) when ) is aligned with the params - does not register an offense when using keyword arguments - for method definitions - with no line break before 1st parameter - registers an offense for misaligned ) - accepts empty () - accepts a correctly aligned ) - with line break before 1st parameter - accepts a correctly aligned ) - registers an offense for misaligned ) +RuboCop::Formatter::SimpleTextFormatter + #report_summary + when 2 offenses are corrected + handles pluralization correctly + when an offense is corrected + prints about correction + when 2 offenses detected + handles pluralization correctly + when a offense detected and a offense autocorrectable + handles pluralization correctly + when 2 offenses detected and 2 offenses autocorrectable + handles pluralization correctly + when a file inspected and no offenses detected + handles pluralization correctly + when 2 offenses are corrected and 2 offenses autocorrectable + handles pluralization correctly + when a offense detected + handles pluralization correctly + when no files inspected + handles pluralization correctly + #report_file + behaves like report for severity + the file is under the current working directory + prints as relative path + when the offense is correctable + prints message as-is + when the offense is not corrected + prints message as-is + when the offense is automatically corrected + prints [Corrected] along with message + when the offense is marked as todo + prints [Todo] along with message + the file is outside of the current working directory + prints as absolute path + behaves like report for severity + when the offense is not corrected + prints message as-is + when the offense is automatically corrected + prints [Corrected] along with message + the file is under the current working directory + prints as relative path + when the offense is marked as todo + prints [Todo] along with message + when the offense is correctable + prints message as-is + the file is outside of the current working directory + prints as absolute path + behaves like report for severity + the file is outside of the current working directory + prints as absolute path + the file is under the current working directory + prints as relative path + when the offense is correctable + prints message as-is + when the offense is automatically corrected + prints [Corrected] along with message + when the offense is marked as todo + prints [Todo] along with message + when the offense is not corrected + prints message as-is + behaves like report for severity + the file is outside of the current working directory + prints as absolute path + when the offense is automatically corrected + prints [Corrected] along with message + when the offense is correctable + prints message as-is + when the offense is marked as todo + prints [Todo] along with message + the file is under the current working directory + prints as relative path + when the offense is not corrected + prints message as-is + behaves like report for severity + the file is under the current working directory + prints as relative path + when the offense is automatically corrected + prints [Corrected] along with message + the file is outside of the current working directory + prints as absolute path + when the offense is not corrected + prints message as-is + when the offense is correctable + prints message as-is + when the offense is marked as todo + prints [Todo] along with message + behaves like report for severity + the file is under the current working directory + prints as relative path + when the offense is not corrected + prints message as-is + when the offense is marked as todo + prints [Todo] along with message + when the offense is automatically corrected + prints [Corrected] along with message + when the offense is correctable + prints message as-is + the file is outside of the current working directory + prints as absolute path -RuboCop::Cop::Layout::FirstArrayElementIndentation - when array is operand - accepts correctly indented first element - registers an offense and corrects incorrectly indented ] - registers an offense and corrects incorrectly indented first element - when indentation width is overridden for this cop - registers an offense and corrects incorrectly indented 1st element - accepts correctly indented first element - when array is method argument - and argument are not surrounded by parentheses - accepts indent based on the left bracket when the outer hash key and the left bracket is not on the same line - accepts single line array with brackets - registers an offense for incorrectly indented multi-line array that is the value of a single pair hash - accepts bracketless array - registers an offense and corrects incorrectly indented multi-line array with brackets - accepts indent based on the start of the line where the left bracket iswhen the right bracket and its following pair is on the same line - accepts a correctly indented multi-line array with brackets - registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key - and arguments are surrounded by parentheses - and EnforcedStyle is special_inside_parentheses - registers an offense and corrects 'align_brackets' indentation - registers an offense for incorrectly indented multi-line array that is the value of a single pair hash - registers an offense and corrects 'consistent' indentation - accepts indent based on the preceding left parenthesis when the right bracket and its following pair is on the same line - accepts normal indentation for array within array - registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key - accepts special indentation for second argument - accepts special indentation for first argument - accepts indent based on the left brace when the outer hash key and the left bracket is not on the same line - when using safe navigation operator - registers an offense and corrects 'consistent' indentation - and EnforcedStyle is consistent - registers an offense for incorrectly indented multi-line array that is the value of a single pair hash - registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key - accepts normal indentation for second argument - accepts indent based on the left brace when the outer hash key and the left bracket is not on the same line - registers an offense and corrects incorrect indentation - accepts normal indentation for first argument - accepts indent based on the start of the line where the left bracket iswhen the right bracket and its following pair is on the same line - when array is right hand side in assignment - accepts single line array - registers an offense and corrects incorrectly indented first element - accepts an empty array - accepts correctly indented first element - accepts several elements per line - accepts multi-assignments with no brackets - accepts a first element on the same line as the left bracket - accepts multi-assignments with brackets - when array is argument to setter - accepts correctly indented first element - registers an offense and corrects incorrectly indented first element - when EnforcedStyle is align_brackets - accepts an empty array - accepts correctly indented first element - registers an offense and corrects incorrectly indented ] - accepts multi-assignments with brackets - accepts a first element on the same line as the left bracket - accepts multi-assignments with no brackets - accepts single line array - accepts several elements per line - when 'consistent' style is used - registers an offense and corrects incorrectly indented 1st element - registers an offense and corrects incorrect indentation - when indentation width is overridden for this cop - registers an offense and corrects indentation that does not match IndentationWidth - accepts correctly indented first element - when 'special_inside_parentheses' style is used - registers an offense and corrects incorrect indentation +RuboCop::Cop::Style::PerlBackrefs + autocorrects $' to Regexp.last_match.post_match + autocorrects $MATCH to Regexp.last_match(0) + autocorrects $POSTMATCH to Regexp.last_match.post_match + autocorrects "#$1" to "#{Regexp.last_match(1)}" + autocorrects $& to Regexp.last_match(0) + autocorrects `#$1` to `#{Regexp.last_match(1)}` + autocorrects $PREMATCH to Regexp.last_match.pre_match + autocorrects $1 to ::Regexp.last_match(1) in namespace + autocorrects $LAST_PAREN_MATCH to Regexp.last_match(-1) + autocorrects puts $1 to puts Regexp.last_match(1) + autocorrects $` to Regexp.last_match.pre_match + autocorrects $9 to Regexp.last_match(9) + autocorrects /#$1/ to /#{Regexp.last_match(1)}/ + autocorrects $+ to Regexp.last_match(-1) RuboCop::Cop::Cop + keeps track of offenses will set default severity - initially has 0 offenses - will report registered offenses will warn if custom severity is invalid + will report registered offenses will set custom severity if present - keeps track of offenses - .documentation_url - for a custom cop class - is expected to be nil - for a builtin cop class - is expected to eq "https://docs.rubocop.org/rubocop/cops_layout.html#layoutblockendnewline" - with style cops - has right department - has right name - with no submodule - has right name - has right department - .qualified_cop_name - returns the cop name in a different namespace if the provided namespace is incorrect - returns the given cop name if it already has a namespace - adds namespace if the cop name is found in exactly one namespace - returns the given cop name if it is not found in any namespace - returns the given cop name if it already has a namespace even when the cop exists in multiple namespaces - raises an error if the cop name is in more than one namespace + initially has 0 offenses #safe_autocorrect? + when autocorrection of the cop is declared unsafe + is expected to equal false when safety is undeclared is expected to equal true when cop is declared unsafe is expected to equal false - when autocorrection of the cop is declared unsafe - is expected to equal false - for a cop with a name - registers offense with its name - with lint cops + with no submodule has right department has right name - Registry - #departments - has departments - is expected to include :Lint - contains every value only once - is expected to include :Style - #with_department - returns 0 for an invalid type - has each cop in exactly one type - has at least one cop per department + for a cop with a name + registers offense with its name setting of Offense#corrected attribute - when cop supports autocorrection - when offense was corrected - is set to true - when autocorrection is not needed - is set to false - when offense was not corrected because of an error - is set to false when cop does not support autocorrection is not specified (set to nil) when autocorrect is requested is not specified (set to nil) when disable_uncorrectable is enabled is set to true - when disabled by a comment - ignore_disable_comments is false - will set offense as disabled - ignore_disable_comments is true - will not set offense as disabled - #relevant_file? - when the file matches the Include configuration - is expected to equal true - when the file doesn't match the Include configuration - is expected to equal false - when the file is an anonymous source - is expected to equal true + when cop supports autocorrection + when autocorrection is not needed + is set to false + when offense was corrected + is set to true + when offense was not corrected because of an error + is set to false + .qualified_cop_name + returns the given cop name if it already has a namespace + raises an error if the cop name is in more than one namespace + returns the given cop name if it is not found in any namespace + adds namespace if the cop name is found in exactly one namespace + returns the cop name in a different namespace if the provided namespace is incorrect + returns the given cop name if it already has a namespace even when the cop exists in multiple namespaces + Registry + #with_department + has at least one cop per department + has each cop in exactly one type + returns 0 for an invalid type + #departments + is expected to include :Style + is expected to include :Lint + has departments + contains every value only once + with lint cops + has right name + has right department #autocorrect? - when the option is not given - is expected to equal false when the option is given is expected to equal true + when the cop is set to not autocorrect + is expected to equal false when cop does not support autocorrection is expected to equal false when disable_uncorrectable is enabled is expected to equal true - when the cop is set to not autocorrect - is expected to equal false - -RuboCop::Cop::Lint::RedundantCopDisableDirective - .check - autocorrecting whitespace - inline comment - removes the comment and preceding whitespace - when the comment is not the first line of the file - preserves whitespace before the comment - nested inside a namespace - preserves indentation - when the comment is the first line of the file - followed by another comment - removes the comment and newline - followed by code - removes the comment - followed by a newline - removes the comment and newline - when there is only whitespace before the comment - leaves the whitespace - when there is a blank line before inline comment - removes the comment and preceding whitespace - when there are disabled lines - and there are no offenses - and a comment disables - a cop that is disabled in the config - returns an offense - when that cop was previously enabled - returns no offense - if that cop has offenses - returns an offense - itself and another cop - disabled on the same range - returns no offense - disabled on different ranges - returns no offense - and the other cop is disabled a second time - returns no offense - one cop - returns an offense - misspelled cops - returns an offense - itself and all cops - disabled on different ranges - returns no offense - multiple cops - returns an offense - all cops - returns an offense - when using a directive comment after a non-directive comment - returns an offense - multiple cops, and one of them has offenses - returns an offense - multiple cops, and the leftmost one has no offenses - returns an offense - an unknown cop - returns an offense - multiple cops, with abbreviated names - one of them has offenses - returns an offense - comment is not at the beginning of the file - and not all cops have offenses - returns an offense - and there are two offenses - and a comment disables - one cop twice - returns an offense - one cop and then all cops - returns an offense - and there is an offense - and a comment disables - that cop - returns no offense - all cops - returns no offense - that cop but on other lines - returns an offense - when there are no disabled lines - returns no offense - with a disabled department - does not remove correct department - removes cop duplicated by department on previous line - removes cop duplicated by department - removes entire comment - removes redundant department - removes cop duplicated by department and leaves free text as a comment + when the option is not given + is expected to equal false + #relevant_file? + when the file matches the Include configuration + is expected to equal true + when the file doesn't match the Include configuration + is expected to equal false + when the file is an anonymous source + is expected to equal true + when disabled by a comment + ignore_disable_comments is false + will set offense as disabled + ignore_disable_comments is true + will not set offense as disabled + with style cops + has right department + has right name + .documentation_url + for a builtin cop class + is expected to eq "https://docs.rubocop.org/rubocop/cops_layout.html#layoutblockendnewline" + for a custom cop class + is expected to be nil -RuboCop::Cop::Lint::EmptyExpression - when used as a return value - registers an offense in the return value of a condition - registers an offense in the return value of a method - registers an offense in the return value of a case statement - when used in a condition - registers an offense inside `if` - registers an offense in the condition of a ternary operator - registers an offense inside `elsif` - registers an offense inside `case` - registers an offense inside `when` - registers an offense in the return value of a ternary operator - when used as an assignment - registers an offense for the assigned value - when used as a standalone expression - registers an offense - with nested empty expressions - registers an offense +RuboCop::Formatter::MarkdownFormatter + outputs the cached result in Markdown + outputs the result in Markdown -RuboCop::Cop::Style::NumericPredicate - when configured to enforce numeric predicate methods - with checking if a number is not zero - allows comparing against a variable - allows comparing against a complex expression - allows comparing against a global variable - when checking if a number is negative - when target ruby version is 2.3 or higher - registers an offense in yoda condition - registers an offense - with a complex expression - registers an offense in yoda condition - registers an offense - when target ruby version is 2.2 or lower - does not register an offense - when checking if a number is positive - when target ruby version is 2.3 or higher - registers an offense - registers an offense in yoda condition - with a complex expression - registers an offense in yoda condition - registers an offense - when target ruby version is 2.2 or lower - does not register an offense - when checking if a number is zero - allows comparing against a global variable - registers an offense - registers an offense with a complex expression - when comparing against a method argument variable - registers an offense with complex expression - registers an offense - when there are allowed methods - simple method call - `EnforcedStyle` is `predicate` - allows checking if a number is zero - `EnforcedStyle` is `comparison` - allows checking if a number is zero - in argument - not ignored method - when checking if a number is negative - when target ruby version is 2.2 or lower - does not register an offense - when target ruby version is 2.3 or higher - registers an offense - when checking if a number is positive - when target ruby version is 2.2 or lower - does not register an offense - when target ruby version is 2.3 or higher - registers an offense - ignored method - with a string - allows checking if a number is negative - allows checking if a number is positive - with a regex - allows checking if a number is negative - allows checking if a number is positive - in block - not ignored method - registers an offense for checking if a number is negative - registers an offense for checking if a number is positive - ignored method - with a string - allows checking if a number is negative - allows checking if a number is positive - with a regex - allows checking if a number is negative - allows checking if a number is positive - when configured to enforce numeric comparison methods - registers an offense for checking if a number is zero - allows checking if a number is not zero - registers an offense for checking if a number is negative - registers an offense for checking if a number is positive +RuboCop::Cop::Lint::NumberedParameterAssignment + does not register an offense when using non numbered parameter + registers an offense when using `_10` lvar + registers an offense when using `_0` lvar + does not register an offense when index assignment + when Ruby 2.7 or lower + registers an offense when using `_1` numbered parameter + registers an offense when using `_5` numbered parameter + registers an offense when using `_9` numbered parameter + registers an offense when using `_6` numbered parameter + registers an offense when using `_7` numbered parameter + registers an offense when using `_3` numbered parameter + registers an offense when using `_2` numbered parameter + registers an offense when using `_8` numbered parameter + registers an offense when using `_4` numbered parameter -RuboCop::Cop::Style::ClassMethods - does not register an offense outside class/module bodies - registers an offense for methods using a class name - registers an offense for methods using a module name - does not register an offense for other top-level singleton methods - does not register an offense for methods using self +RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + #calculate + with ||= + is expected to eq "<2, 0, 1>" + multiple calls with return + is expected to eq "<0, 3, 0>" + with unused assignments + is expected to eq "<2, 1, 0>" + method with arguments + is expected to eq "<4, 0, 0>" + when discounting repeated calls + when root receiver is self/nil + is expected to eq "<2, 9, 1>" + when root receiver is a var + is expected to eq "<3, 9, 0>" + when some calls have arguments + is expected to eq "<1, 7, 0>" + with []= + is expected to eq "<2, 1, 0>" + same with extra condition + is expected to eq "<2, 9, 5>" + assignment with ternary operator + is expected to eq "<2, 6, 2>" + with ||= on a constant + is expected to eq "<1, 0, 1>" + multiple assignment + is expected to eq "<3, 1, 0>" + with &&= + is expected to eq "<2, 0, 1>" + with a block + is expected to eq "<2, 3, 0>" + with += + is expected to eq "<2, 0, 0>" + if and arithmetic operations + is expected to eq "<2, 8, 4>" + same but with 7 arguments + is expected to eq "<9, 3, 0>" + elsif vs else if + else if + is expected to eq "<0, 5, 4>" + elsif + is expected to eq "<0, 5, 3>" + with a yield + is expected to eq "<0, 1, 0>" + with &.foo + is expected to eq "<0, 4, 2>" + with repeated lvar receivers + is expected to eq "<3, 5, 3>" + with += for setters + is expected to eq "<1, 2, 0>" + when counting repeated calls + is expected to eq "<1, 4, 0>" + with a for + is expected to eq "<2, 1, 1>" + with .foo = + is expected to eq "<1, 2, 0>" + with a known iterating block + is expected to eq "<2, 4, 2>" + multiple assignment with method setters + is expected to eq "<3, 5, 0>" + equivalent to multiple assignment with method setters + is expected to eq "<3, 5, 0>" -RuboCop::Cop::Lint::AmbiguousBlockAssociation - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts +RuboCop::Cop::Lint::DuplicateRegexpCharacterClassElement + with a repeated character posix character class inside a group + registers an offense and corrects + with a repeated character class element + registers an offense and corrects + with repeated character class elements when `"\0\08"` (means `"\u0000\u00008"`) + registers an offense + with multiple regexps with the same interpolation does not register an offense - behaves like accepts + with a repeated character class element and %r{} literal + registers an offense and corrects + with a repeated character class element with quantifier + registers an offense and corrects + with repeated elements in different character classes does not register an offense - behaves like accepts + with a repeated intersection character class does not register an offense - behaves like accepts + with no repeated character class elements when `"\0\07"` (means `"\u0000\a"`) does not register an offense - when AllowedMethods is enabled - registers an offense for other methods - does not register an offense for an allowed method - when AllowedPatterns is enabled - registers an offense for other methods - does not register an offense for an allowed method - behaves like accepts + with a range that covers a repeated element character class does not register an offense - behaves like accepts + with a repeated character class element inside a group + registers an offense and corrects + with a repeated character class element with interpolation + registers an offense and corrects + with a repeated range element + registers an offense and corrects + with no repeated character class elements does not register an offense - without parentheses - with assignment - registers an offense - without receiver - registers an offense - as a hash key - registers an offense - rspec expect {}.to change {} + +RuboCop::Cop::Style::RedundantEach + does not register an offense when using `each.with_object` + does not register an offense when using `each_with_index` + registers an offense when using `reverse_each.each` + does not register an offense when any method is used between methods with `each` in the method name + does not register an offense when using `each_ancestor.each` + does not register an offense when using `reverse_each(&:foo).each {...}` + registers an offense when using a method starting with `each_` with `each_with_index` + registers an offense when using `each.each_with_index` + registers an offense when using `each.each_with_object` + registers an offense when using `reverse_each.each_with_index` + does not register an offense when using `each_with_object` + does not register an offense when using `each_foo {}.each_with_object([]) {}` + does not register an offense when not chaining `each_` calls + registers an offense when using `each.each(&:foo)` + registers an offense when using a method starting with `each_` with `each_with_object` + does not register an offense when using `each` with a symbol proc argument + does not register an offense when using `each` with a symbol proc for last argument + does not register an offense when using `each` as enumerator + registers an offense when using `reverse_each.each_with_object` + does not register an offense when using `each {}.each_with_index {}` + registers an offense when using `each.reverse_each` + does not register an offense when using only single `each` + does not register an offense when using `each_with_index.reverse_each` + does not register an offense when using `each {}.reverse_each {}` + does not register an offense when using `reverse_each {}.each {}` + does not register an offense when using `each.with_index` + registers an offense when using `each.each` + does not register an offense when using `each {}.each_with_object([]) {}` + +RuboCop::Cop::Style::FrozenStringLiteralComment + always_true + registers an offense for a disabled frozen string literal comment below an encoding comment and extra space + registers an offense for arbitrary tokens below shebang, an encoding comment, and extra space + accepts an emacs style combined magic comment + registers an offense for arbitrary tokens below shebang and encoding comments + registers an offense for arbitrary tokens under shebang with no other code + registers an offense for a disabled frozen string literal comment below shebang above an encoding comments + registers an offense for not having a frozen string literal comment under a shebang and an encoding comment + accepts a frozen string literal below an encoding comment + registers an offense for an extra first empty line + registers an offense for having a frozen string literal comment under ruby code + registers an offense for a disabled frozen string literal above an empty line + registers an offense for not having a frozen string literal comment on the top line + registers an offense for a disabled frozen string literal comment below shebang and encoding comments + registers an offense for arbitrary tokens above an empty line + registers an offense for a disabled frozen string literal comment under shebang with no other code + registers an offense for not having a frozen string literal comment under shebang with no other code + registers an offense for a disabled frozen string literal below an encoding comment + accepts a frozen string literal comment below shebang, an encoding comment, and extra space + accepts a source with no tokens + accepts a frozen string literal below a shebang comment + accepts a frozen string literal comment below an encoding comment and extra space + registers an offense for a disabled frozen string literal comment after other comments + registers an offense for a disabled frozen string literal on the top line + registers an offense for a disabled frozen string literal comment below shebang, an encoding comment, and extra space + registers an offense for not having a frozen string literal comment under an encoding comment + registers an offense for arbitrary tokens below a shebang comment + accepts a frozen string literal comment after other comments + accepts a frozen string literal on the top line + accepts a frozen string literal comment under shebang with no other code + registers an offense for arbitrary tokens below an encoding comment and extra space + registers an offense for arbitrary tokens + accepts an empty source + registers an offense for a disabled frozen string literal below a shebang comment + registers an offense for not having a frozen string literal comment under an encoding comment and extra space + registers an offense for arbitrary tokens below shebang above an encoding comments + registers an offense for not having a frozen string literal comment under a shebang, an encoding comment, and extra space + accepts a frozen string literal comment below shebang and encoding comments + accepts a frozen string literal comment below shebang above an encoding comments + registers an offense for a disabled frozen string literal + registers an offense for arbitrary tokens below an encoding comment + never + registers an offense for a disabled frozen string literal comment below shebang above an encoding comments + registers an offense for a disabled frozen string literal below a shebang comment + registers an offense for a frozen string literal comment below an encoding comment + registers an offense for a frozen string literal comment below shebang and encoding comments + registers an offense for a frozen string literal comment below a shebang comment + registers an offense for a disabled frozen string literal below an encoding comment + accepts not having not having a frozen string literal comment under a shebang + allows not having a frozen string literal comment under an encoding comment + accepts an empty source + accepts not having a frozen string literal comment on the top line + allows not having a frozen string literal comment under a shebang and an encoding comment + registers an offense for a frozen string literal comment below shebang above an encoding comments + registers an offense for a disabled frozen string literal comment below shebang and encoding comments + registers an offense for having a frozen string literal comment after other comments + accepts a source with no tokens + registers an offense for a disabled frozen string literal comment on the top line + registers an offense for a frozen string literal comment on the top line + accepts a frozen string literal comment under ruby code + target_ruby_version < 2.3 + accepts freezing a string + accepts calling << on a string + accepts freezing a string with interpolation + accepts calling << on a string with interpolation + always + accepts a frozen string literal comment below shebang and encoding comments + registers an offense for not having a frozen string literal comment under an encoding comment separated by a newline + accepts a disabled frozen string literal comment below shebang above an encoding comments + registers an offense for not having a frozen string literal comment under a shebang + registers an offense for not having a frozen string literal comment under a shebang and an encoding comment + accepts a disabled frozen string literal comment below shebang and encoding comments + registers an offense for not having a frozen string literal comment under an encoding comment + accepts a disabled frozen string literal below a shebang comment + registers an offense for arbitrary tokens + accepts an emacs style combined magic comment + accepts a frozen string literal comment after other comments + registers an offense with an empty line between magic comments and the code + accepts an empty source + registers an offense for not having a frozen string literal comment when there is only a shebang + accepts a disabled frozen string literal on the top line + registers an offense for having a frozen string literal comment under ruby code + accepts a frozen string literal comment below shebang above an encoding comments + accepts a frozen string literal on the top line + accepts a frozen string literal below a shebang comment + registers an offense for not having a frozen string literal comment on the top line + accepts a frozen string literal below an encoding comment + accepts a source with no tokens + registers an offense for an extra first empty line + accepts a frozen string literal comment below newline-separated magic comments + accepts a disabled frozen string literal below an encoding comment + +RuboCop::Cop::Metrics::ModuleLength + accepts empty modules + does not count blank lines + accepts a module with less than 5 lines + rejects a module with more than 5 lines + accepts a module with 5 lines + reports the correct beginning and end lines + when a module has inner modules + does not count lines of inner modules + rejects a module with 6 lines that belong to the module directly + when `CountAsOne` is not empty + folds array into one line + when inspecting a class defined with Module.new + registers an offense + when inspecting a class defined with ::Module.new + registers an offense + when CountComments is enabled + also counts commented lines + when using numbered parameter + when inspecting a class defined with Module.new registers an offense - with receiver + when inspecting a class defined with ::Module.new registers an offense - when using safe navigation operator - registers an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts - does not register an offense - behaves like accepts + when a module has inner classes + does not count lines of inner classes + rejects a module with 6 lines that belong to the module directly + +RuboCop::Cop::Style::AccessorGrouping + when EnforcedStyle is grouped + registers an offense and corrects when using separated accessors with different access modifiers + does not register an offense when using grouped accessors + registers an offense and corrects when using separated accessors + does not register an offense when the same accessor is given more than once in the same statement + registers offense and corrects if at least two separate accessors without comments + registers an offense and correct if the same accessor is listed twice + does not register offense for accessors with comments + registers an offense and corrects when using separated accessors within eigenclass + when EnforcedStyle is separated + registers an offense and corrects when the same accessor is given more than once in the same statement + registers an offense and corrects when using grouped accessors within eigenclass + registers an offense and corrects when using grouped accessors with different access modifiers + does not register an offense if the same accessor is listed twice + registers an offense and corrects when using grouped accessors + does not register an offense for grouped accessors with comments + does not register an offense when using separated accessors + when there are comments for attributes + registers and corrects an offense + +RuboCop::Cop::Layout::EmptyLineAfterMultilineCondition + does not register an offense when new line after modifier `while` with multiline condition + registers an offense when no new line after modifier `if` with multiline condition + registers an offense when no new line after `rescue` with multiline exceptions + does not register an offense when new line after `rescue` with multiline exceptions + does not register an offense when new line after modifier `if` with multiline condition + registers an offense when no new line after `until` with multiline condition + does not register an offense when modifier `while` with multiline conditionis the last child of its parent + registers an offense when no new line after `elsif` with multiline condition + does not register an offense when new line after `while` with multiline condition + does not register an offense when new line after `if` with multiline condition + registers an offense when no new line after `while` with multiline condition + does not register an offense when new line after `when` with multiline condition + registers an offense when no new line after `if` with multiline condition + registers an offense when no new line after `when` with multiline condition + does not register an offense for `if` with single line condition + registers an offense when no new line after modifier `while` with multiline condition + does not register an offense for `while` with single line condition + does not register an offense when `if` at the top level + does not register an offense for `rescue` with singleline exceptions + does not register an offense when new line after `elsif` with multiline condition + does not register an offense when modifier `if` with multiline conditionis the last child of its parent + does not register an offense for `when` with singleline condition + +RuboCop::Cop::Layout::EmptyLineAfterGuardClause + accepts a guard clause inside oneliner block + accepts a guard clause when the next line is `elsif` + accepts a modifier if when the next line is `end` + accepts a guard clause when the next line is `ensure` + does not register an offense when the clause ends with a semicolon but is followed by a newline + accepts using guard clause is after `raise` + registers an offense and corrects a `raise` guard clause not followed by empty line when guard clause is after method call with argument + accepts using guard clause is after `rubocop:enable` comment + registers an offense and corrects when using `or return` before guard condition + registers an offense and corrects only the last guard clause + accepts a `raise` guard clause not followed by empty line when guard clause is after condition without method invocation + does not register an offense when the clause is not followed by other code + registers an offense and corrects a guard clause that is a ternary operator + registers an offense and corrects `next` guard clause not followed by empty line + accepts a guard clause that is after a multiline heredoc with chained calls + accepts multiple guard clauses + registers an offense and corrects a `raise` guard clause not followed by empty line when `unless` condition is after heredoc + registers no offenses using heredoc with `and return` before guard condition with empty line + accepts modifier if + accepts a guard clause followed by empty line when guard clause including heredoc + registers and corrects when using guard clause is after `rubocop:enable` comment + registers and corrects when using guard clause is after `rubocop:disable` comment + registers an offense and corrects a method starting with end_ + accepts a guard clause when the next line is `rescue` + accepts a guard clause that is after a multiline heredoc nested argument call + registers an offense and corrects a guard clause not followed by empty line + registers an offense and corrects a next guard clause not followed by empty line when guard clause is after heredoc including string interpolation + accepts a guard clause that is after multiline heredoc + accepts a guard clause after a single line heredoc + accepts a guard clause when the next line is `rescue`-`else` + registers an offense and corrects a `raise` guard clause not followed by empty line when `if` condition is after heredoc + accepts a guard clause followed by end + registers an offense and corrects a guard clause not followed by empty line when guard clause including heredoc + registers an offense when the clause ends with a semicolon but the next clause is on the next line + registers an offense and corrects using heredoc with `and return` before guard condition + registers an offense and corrects when using `and return` before guard condition + registers an offense and corrects a guard clause is before `begin` + does not register an offense when there are multiple clauses on the same line + accepts a guard clause when the next line is `else` + +RuboCop::Cop::Style::StringHashKeys + does not register an offense when string key is used in IO.popen + does not register an offense when string key is used in gsub + registers an offense when using strings as keys mixed with other keys + does not register an offense when not using strings as keys + does not register an offense when string key is used in Open3.pipeline + does not register an offense when string key is used in gsub! + registers an offense when using strings as keys + autocorrects strings as keys into symbols with the correct syntax + does not register an offense when string key is used in Open3.capture3 + +RuboCop::Cop::Lint::Debugger + does not register an offense for a pry method + does not register an offense for a debugger in comments + does not register an offense for a byebug method + does not register an offense for a binding method that is not disallowed + does not register an offense for a irb method + does not register an offense for a save_and_open_page in comments + does not register an offense for a remote_byebug method + does not register an offense for a console in comments + does not register an offense for a pry in comments + does not register an offense for a remote_pry method + does not register an offense for a save_and_open_page method + does not register an offense for a remote_byebug in comments + does not register an offense for a byebug in comments + does not register an offense for a debugger method + does not register an offense for a remote_pry in comments + does not register an offense for a irb in comments + does not register an offense for a console method + does not register an offense for a pry_remote method + does not register an offense for a save_and_open_screenshot method + does not register an offense for a pry_remote in comments + does not register an offense for a save_and_open_screenshot in comments + web console + registers an offense for a `binding.console` call + does not register an offense for `console` without a receiver + debug.rb + registers an offense for a `b` binding call + registers an offense for a `break` binding call + registers an offense for a `binding.break` with `Kernel` call + registers an offense for a `binding.b` with `Kernel` call + rails + registers an offense for a debugger with Kernel call + registers an offense for a debugger with ::Kernel call + registers an offense for a debugger with an argument call + registers an offense for a debugger call + capybara + registers an offense for save_and_open_page + registers an offense for save_and_open_screenshot + with an argument + registers an offense for save_and_open_page + registers an offense for save_and_open_screenshot + when a method group is disabled with false + does not register an offense for a Pry debugger call + does register an offense for another group + byebug + registers an offense for a remote_byebug call + registers an offense for a byebug call + registers an offense for a Kernel.remote_byebug call + registers an offense for a Kernel.byebug call + registers an offense for a byebug with an argument call + when a method group is disabled with nil + does not register an offense for a Pry debugger call + does register an offense for another group + built-in methods + registers an offense for a binding.irb with Kernel call + registers an offense for a irb binding call + pry + registers an offense for a Pry.rescue call + registers an offense for a pry_remote binding with an argument call + registers an offense for a remote_pry binding call + does not register an offense for a `rescue` call without Pry + registers an offense for a pry binding call + registers an offense for a remote_pry binding with an argument call + does not register an offense for a `pry` call without binding + registers an offense for a pry binding with an argument call + registers an offense for a binding.pry with Kernel call + registers an offense for a pry_remote binding call + with the DebuggerMethods configuration + registers an offense for a `custom_debugger` call + does not register an offense for a byebug call + with a const chain + registers an offense for a `Foo::Bar::Baz.debug` call + with a const chain and a method chain + registers an offense for a `Foo::Bar::Baz.debug.this.code` call + nested custom configurations + registers an offense for a `custom_debugger call + with a method chain + registers an offense for a `debugger.foo.bar` call + RubyJard + registers an offense for a jard call + +RuboCop::Cop::VariableForce + #process_node + when processing a regexp with a line break at the start of capture parenthesis + does not raise an error + when processing an empty regex + does not raise an error + when processing lvar node + when the variable is not yet declared + does not raise error + when processing a regex with regopt + does not raise an error + +RuboCop::Cop::Security::Open + accepts open with a literal string starting with a pipe + registers an offense for open + accepts open with a string that interpolates a literal + registers an offense for open with dynamic string that is not prefixed + registers an offense for `URI.open` with a block + registers an offense for open with a block + registers an offense for open with mode argument + registers an offense for `URI.open` with string that starts with a pipe + accepts open with no arguments + registers an offense for `::URI.open` with string that starts with a pipe + accepts open on a literal string + accepts open as variable + registers an offense for open with string that starts with a pipe + accepts open with string that has a prefixed interpolation + accepts open with prefix string literal plus something + accepts File.open as method + +RuboCop::Cop::Security::YAMLLoad + registers an offense and corrects load with a literal string + does not register an offense for YAML.load under a different namespace + does not register an offense for YAML.dump + registers an offense and corrects a fully qualified ::YAML.load + Ruby >= 3.1 + does not register an offense and corrects load with a literal string + does not register an offense and corrects a fully qualified `::YAML.load` + +RuboCop::Server::Cache + .cache_path + when cache root path is not specified as default + is the default path + when `RUBOCOP_CACHE_ROOT` environment variable is set + when cache root path is not specified path + contains the root from `RUBOCOP_CACHE_ROOT` + when cache root path is not specified path and `XDG_CACHE_HOME` environment variable is specified + contains the root from `RUBOCOP_CACHE_ROOT` + when cache root path is specified path + contains the root from cache root path + when `CacheRootDirectory` configure value is set + when cache root path is not specified path + contains the root from `CacheRootDirectory` configure value + when cache root path is not specified path and `XDG_CACHE_HOME` environment variable is spacified + contains the root from `CacheRootDirectory` configure value + when cache root path is specified path + contains the root from cache root path + when ERB pre-processing of the configuration file + when cache root path is not specified path + does not raise an error + when `XDG_CACHE_HOME` environment variable is set + when cache root path is specified path + contains the root from cache root path + when cache root path is not specified path + contains the root from `XDG_CACHE_HOME` + when .rubocop.yml is empty + when cache root path is not specified path + does not raise an error + when cache root path is specified path + is the specified path + .pid_running? + works properly when concurrency with server stopping and cleaning cache dir + +RuboCop::Cop::Lint::RedundantWithObject + registers an offense and corrects when using ary.each_with_object do-end block without parentheses + registers an offense and corrects when using `ary.each_with_object { |v| v }` + registers an offense and corrects when using ary.each_with_object([]) do-end block + an object is used as a block argument + registers an offense and corrects when using `ary.each.with_object([]) { |v| v }` + Ruby 2.7 + registers an offense and corrects when using `ary.each_with_object { _1 }` + registers an offense and corrects when using `ary.each.with_object([]) { _1 }` + when missing argument to `each_with_object` + does not register an offense when block has 1 argument + does not register an offense when block has 2 arguments + +RuboCop::Cop::Style::YodaCondition + enforce yoda + accepts number on left of <=> + accepts variable on right after assignment + accepts string literal on right of case equality check + accepts numbers on both sides + registers an offense for boolean literal on right + accepts global variable on right + accepts subtraction on right of comparison + registers an offense for string literal on right + registers an offense for number on right + accepts negation + accepts class variable on right + accepts safe navigation on right + registers an offense for nil on right + registers an offense for number on right of comparison + accepts instance variable on right + accepts arrays of numbers on both sides + accepts assignment + accepts string literal on left + accepts accessor and variable on right in boolean expression + accepts method call on receiver on right + with EnforcedStyle: require_for_equality_operators_only + registers an offense for negated equality check + registers an offense for equality check + accepts mixed order in comparisons + accepts nil on right of comparison + accepts number on right of comparison + within an if or ternary statement + registers an offense number on right of comparison in if condition + registers an offense number on right in if condition + registers an offense for number on right of >= in ternary condition + registers an offense for number on right in modifier if + registers an offense for number on right of <= in ternary condition + registers an offense for nil on right in ternary condition + enforce not yoda + accepts interpolated string on left + accepts class variable on left + accepts __FILE__ on left in negated program name check + accepts instance variable on left + accepts array of numbers on both sides + registers an offense for nil on left + accepts string literal on right + registers an offense for string literal on left + accepts negation + accepts interpolated regex on left + registers an offense number on left + accepts number on both sides + accepts assignment + accepts global variable on left + registers an offense for boolean literal on left + accepts number on left of <=> + accepts __FILE__ on left in program name check + accepts subtraction expression on left of comparison + accepts string literal on left of case equality check + accepts variable on left after assign + accepts accessor and variable on left in boolean expression + accepts safe navigation on left + accepts method call on receiver on left + registers an offense number on left of comparison + with EnforcedStyle: forbid_for_equality_operators_only + accepts nil on left of comparison + accepts number on left of comparison + registers an offense for negated equality check + accepts mixed order in comparisons + registers an offense for equality check + within an if or ternary statement + registers an offense for number on left of >= in ternary condition + registers an offense for number on left of <= in ternary condition + registers an offense for number on left in modifier if + registers an offense for number on left of comparison in if condition + registers an offense for number on left in if condition + registers an offense for nil on left in ternary condition + +RuboCop::Cop::Layout::EmptyComment + registers an offense and corrects using single line empty comment + registers an offense and corrects an empty comment without space next to code + registers an offense and corrects using multiline empty comments + registers an offense and corrects using an empty comment next to code + register offenses and correct multiple empty comments next to code + register offenses and correct multiple aligned empty comments next to code + does not register an offense when using comment text with leading and trailing blank lines + does not register an offense when using comment text + allow border comment (default) + does not register an offense when using border comment + allow margin comment (default) + does not register an offense when using margin comment + disallow border comment + registers an offense and corrects using border comment + registers an offense and corrects using single line empty comment + disallow margin comment + registers an offense and corrects using margin comment + +RuboCop::Cop::Style::FetchEnvVar + registers an offense when using `ENV || x` that is different from `if` condition in the body + registers an offense with using an `ENV` at multiple `if` condition in the body + registers an offense when using `ENV && x` that is different from `if` condition in the body + registers an offense when using an `ENV` at `if` condition in the body + when it is compared `!=` with other object does not register an offense - behaves like accepts + when the node is a assigned by `||=` + registers an offense + when the env val is excluded from the inspection by the config + registers no offenses + when `ENV[]` is the right end of `||` chains + registers an offense + when it is a hash key + registers an offense + when it is compared `==` with other object does not register an offense - behaves like accepts + when it is a hash value + registers an offense + when it is an array element + registers an offense + when it receives a message + registers no offenses + when the node is a receiver of `&&=` does not register an offense - behaves like accepts + with negation + registers no offenses + when it is assigned to a variable + registers an offense when using single assignment + registers an offense when using multiple assignment + when the node is a assigned by `&&=` + registers an offense + when it receives a message with safe navigation + registers no offenses + when it is used in an interpolation + registers an offense + when it is an argument of a method + registers an offense + when `ENV[]` is the LHS of `||` + registers no offenses + when using `fetch` instead of `[]` + registers no offenses + when it is used in a conditional expression + registers no offenses when using the same `ENV` var as `if` condition in the body + registers no offenses when using the same `ENV` var as `if` condition in the body with assignment method + registers an offense when using an `ENV` var that is different from `if` condition in the body + registers no offenses with ternary operator + registers no offenses when using the same `ENV` var as `if` condition in the body with predicate method + registers an offense with `case` + registers an offense with using an `ENV` var as `if` condition in the body with assignment method + registers no offenses with `if` + registers no offenses with `unless` + registers no offenses when using the same `ENV` var as `if` condition in the body with other conditions + registers no offenses when using the same `ENV` var as `if` condition in the body with operator + when the node is a receiver of `||=` does not register an offense + when it is evaluated with no default values + registers an offense -RuboCop::Cop::Style::EndBlock - reports an offense and corrects END block - does not report offenses for other blocks +RuboCop::Cop::Style::CaseEquality + when AllowOnSelfClass is true + does not fail when the receiver is implicit + registers an offense and corrects for === when the receiver is a regexp + does not register an offense for === when the receiver is self.class + registers an offense and does not correct for === when receiver is of some other type + does not register an offense for === when the receiver is not a camel cased constant + registers an offense and corrects for === when the receiver is a range + registers an offense and corrects for === when the receiver is self.klass + when AllowOnConstant is false + registers an offense and does not correct for === when receiver is of some other type + does not fail when the receiver is implicit + does not register an offense for === when the receiver is not a camel cased constant + registers an offense and corrects for === when the receiver is a constant + registers an offense and corrects for === when the receiver is a regexp + registers an offense and corrects for === when the receiver is a range + when AllowOnSelfClass is false + registers an offense and does not correct for === when receiver is of some other type + does not register an offense for === when the receiver is not a camel cased constant + registers an offense and corrects for === when the receiver is a range + registers an offense and corrects for === when the receiver is self.class + does not fail when the receiver is implicit + registers an offense and corrects for === when the receiver is a regexp + when AllowOnConstant is true + does not register an offense for === when the receiver is a constant + does not fail when the receiver is implicit + does not register an offense for === when the receiver is not a camel cased constant + registers an offense and corrects for === when the receiver is a regexp + registers an offense and corrects for === when the receiver is a range + registers an offense and does not correct for === when receiver is of some other type + +RuboCop::Cop::Style::SoleNestedConditional + registers an offense and corrects when there are outer and inline comments + does not register an offense when using nested conditional within `elsif` + registers an offense and corrects when using nested conditional and branch contains a comment + registers an offense and corrects when using nested `if` modifier conditional + does not register an offense when using nested modifier on value assigned in single condition + registers an offense and corrects when using `unless` and method arguments without parentheses in the outer condition and nested modifier condition + does not register an offense for nested conditionals when outer conditional has an `else` branch + registers an offense and corrects when `unless` foo do_something end `if` bar + does not register an offense when using nested conditional is not the whole body + registers an offense and corrects when nested `||` operator condition + registers an offense and corrects when nested `||` operator modifier condition + registers an offense and corrects when using `||` in the outer condition and nested modifier condition + registers an offense and corrects when `if` foo do_something end `if` bar + registers an offense and corrects when `if` foo do_something end `unless` bar && baz + registers an offense and corrects when using nested `if` within `unless foo == bar` + registers an offense and corrects when using `unless` and `||` and parens in the outer condition and nested modifier condition + registers an offense and corrects when using nested `unless` within `if` + registers an offense and corrects when using `||` in the outer condition + registers an offense and corrects when using `unless` and `&&` without parens in the outer condition and nested modifier condition + registers an offense and corrects when `if` foo && bar do_something end `if` baz + registers an offense and corrects when `if` foo && bar do_something end `unless` baz + does not register an offense when using nested ternary within conditional + registers an offense and corrects when using nested `unless` modifier with a single expression condition + registers an offense and corrects when `if` foo do_something end `if` bar && baz + registers an offense and corrects when using guard conditional with outer comment + registers an offense and corrects when using `unless` and multiple method arguments with parenthesesin the outer condition and nested modifier condition + does not register an offense when nested conditional has an `else` branch + registers an offense and corrects when using nested `if` within `if` + registers an offense and corrects for multiple nested conditionals + registers an offense and corrects when using nested `if` within `if foo = bar` + registers an offense and corrects when using `unless` and `||` without parens in the outer condition and nested modifier condition + does not register an offense when using nested modifier on value assigned in multiple conditions + registers an offense and corrects when using `unless` and method arguments with parentheses in the outer condition and nested modifier condition + registers an offense and corrects when using nested `unless` modifier multiple conditional + registers an offense and corrects when using nested `unless` modifier conditional + registers an offense and corrects when `if` foo do_something end `unless` bar + does not register an offense when no nested conditionals + registers an offense and corrects when `unless` foo && bar do_something end `if` baz + registers an offense and corrects when using nested `if` within `unless` + registers an offense and corrects when using nested `unless` within `unless` + registers an offense and corrects for multiple nested conditionals with using method call outer condition by omitting parentheses + when the inner condition has a send node with parens + in modifier style + registers an offense and corrects + in guard style + registers an offense and corrects + when AllowModifier is true + does not register an offense when using nested modifier conditional + when the inner condition has a send node without parens + in modifier style + registers an offense and corrects + with a `csend` node + registers an offense and corrects + with a block + registers an offense and corrects + in guard style + registers an offense and corrects + when disabling `Style/IfUnlessModifier` + registers an offense and corrects when there are outer and inline comments + registers an offense and corrects when using nested conditional and branch contains a comment + +RuboCop::Cop::Style::MethodCalledOnDoEndBlock + with a multi-line do..end block + accepts a chained block + registers an offense for a chained call + accepts it if there is no chained call + when using safe navigation operator + registers an offense for a chained call + with a single-line do..end block + registers an offense for a chained call + accepts a single-line do..end block with a chained block + Ruby 2.7 + registers an offense for a chained call + with a {} block + accepts a multi-line block with a chained call + accepts a single-line block with a chained call + +RuboCop::Cop::Style::RescueModifier + handles modifier rescue in normal rescue + registers an offense for modifier rescue around parallel assignment + does not register an offense for nested normal rescue + registers an offense for modifier rescue + handles parentheses around a rescue modifier + does not register an offense for normal rescue + does not register an offense for normal rescue with ensure + handles more complex expression with modifier rescue + handles modifier rescue in a method + excluded file + processes excluded files with issue + autocorrect + corrects complex rescue modifier + corrects doubled rescue modifiers + when an instance method has implicit begin + handles modifier rescue in body of implicit begin + accepts normal rescue + when a singleton method has implicit begin + handles modifier rescue in body of implicit begin + accepts normal rescue + +RuboCop::Cop::Lint::Syntax + .offenses_from_processed_source + with a parser error + returns an offense + with --display-cop-names option + returns an offense with cop name + with a diagnostic error + returns an offense + with --autocorrect --disable-uncorrectable options + returns an offense + with --display-cop-names option + returns an offense with cop name + +RuboCop::Cop::InternalAffairs::UndefinedConfig + registers an offense when the cop inherits `::RuboCop::Cop::Base` + works with deeper nested cop names + works when the base class is `Cop` instead of `Base` + does not register an offense for implicit configuration keys + ignores `cop_config` in non-cop subclasses + registers an offense when the cop is not within the `RuboCop::Cop` namespace + does not register an offense if using `cop_config` outside of a cop class + registers an offense when the cop inherits `RuboCop::Cop::Base` + registers an offense when the cop has no configuration at all + registers an offense when the cop inherits `Cop::Base` + can handle an empty file + ignores `cop_config` in non-cop classes + element lookup + does not register an offense for defined configuration keys + registers an offense for missing configuration keys + fetch + registers an offense for missing configuration keys + does not register an offense for defined configuration keys + with a default value + does not register an offense for defined configuration keys + registers an offense for missing configuration keys + +RuboCop::Cop::Style::UnlessElse + unless without else + does not register an offense + unless with else + registers an offense + and nested unless with else + registers offenses for both but corrects only the outer unless/else + unless with nested if-else + registers an offense + +RuboCop::Cop::Lint::NestedPercentLiteral + registers offense for multiply nested percent literals + registers no offense for array + registers no offense for empty array + registers offense for nested percent literals + registers no offense for percents in the middle of literals + registers no offense for nestings under percent + registers no offense for percent modifier character in isolation + registers offense for repeated nested percent literals + when handling invalid UTF8 byte sequence + registers no offense for array + registers offense for nested percent literal + +RuboCop::Cop::Layout::BlockEndNewline + registers an offense and corrects when multiline block `}` is not on its own line and using multiple heredoc argument method chain + registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument with method chain + registers an offense and corrects when multiline block `}` is not on its own line and using method chain + registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument + registers an offense and corrects when multiline block end is not on its own line + registers an offense and corrects when a multiline block ends with a method call with hash arguments + accepts multiline blocks with newlines before the end + registers an offense and corrects when multiline block `}` is not on its own line + registers an offense and corrects when multiline block `}` is not on its own line and using multiple heredoc arguments + accepts a one-liner + registers an offense and corrects when a multiline block ends with a hash + registers an offense and corrects when `}` of multiline block without processing is not on its own line + Ruby 2.7 + registers an offense and corrects when multiline block `}` is not on its own line and using heredoc argument + registers an offense and corrects when multiline block `}` is not on its own line and using method chain + +RuboCop::Cop::Style::ClassVars + registers an offense for class variable set in class + registers an offense for class variable declaration + does not register an offense for class variable usage + registers an offense for class variable set on class receiver + +RuboCop::Cop::Style::MultilineMemoization + EnforcedStyle: braces + with a multiline memoization + without braces + when the expression is wrapped in `begin` and `end` keywords + registers an offense for begin...end block on following line + registers an offense for begin...end block on first line + with a multiline memoization + without a `begin` and `end` block + allows with another block on the following line + allows with a conditional on the following line + allows with a conditional on the first line + allows with another block on the first line + with a single line memoization + allows expression on first line + allows expression on the following line + EnforcedStyle: keyword + with a multiline memoization + without a `begin` and `end` block + allows with another block on the first line + allows with a conditional on the first line + allows with a conditional on the following line + allows with another block on the following line + with a multiline memoization + without a `begin` and `end` block + when the expression is wrapped in parentheses + registers an offense with multiline expression + registers an offense when expression starts on first line + registers an offense when expression starts on following line + with a single line memoization + allows expression on the following line + allows expression on first line + +RuboCop::Cop::Lint::RedundantWithIndex + registers an offense when using `ary.each_with_object([]).with_index { |v| v }` and corrects to `ary.each_with_object([]) { |v| v }` + registers an offense when using `ary.each.with_index(1) { |v| v }` and correct to `ary.each { |v| v }` + accepts an index is used as a block argument + registers an offense when using `ary.each.with_index { |v| v }` and corrects to `ary.each` + registers an offense for `ary.each_with_index { |v| v }` and corrects to `ary.each` + Ruby 2.7 + registers an offense for `ary.each_with_index { _1 }` and corrects to `ary.each` + registers an offense when using `ary.each.with_index { _1 }` and corrects to `ary.each` + accepts an index is used as a numblock argument + +RuboCop::Cop::Layout::SpaceBeforeComment + registers an offense and corrects missing space before an EOL comment + registers an offense and corrects after a heredoc + accepts a comment that begins a line + accepts a doc comment + accepts an EOL comment with a preceding space + +RuboCop::Cop::Style::NestedFileDirname + Ruby >= 3.1 + does not register an offense when using non nested `File.dirname(path)` + does not register an offense when using `File.dirname(path, 2)` + registers and corrects an offense when using `File.dirname(path)` nested three times + registers and corrects an offense when using `File.dirname(path)` nested two times + Ruby <= 3.0 + does not register an offense when using `File.dirname(path)` nested two times + +RuboCop::Ext::RegexpNode + #each_capture + when called with a `named: true` + is expected to match [(be an instance of Regexp::Expression::Group::Named)] + when called with a `named: false` + is expected to match [(be an instance of Regexp::Expression::Group::Capture)] + when called without argument + is expected to match [(be an instance of Regexp::Expression::Group::Capture), (be an instance of Regexp::Expression::Group::Named)] + #parsed_tree + with a regexp with subexpressions + has location information + with a regexp not containing interpolation + returns the expected tree + with a regexp containing interpolation + returns the expected blanked tree + with an extended mode regexp with comment + returns the expected tree + with a regexp containing a multi-line interpolation + returns the expected blanked tree + +RuboCop::Cop::Style::StringLiterals + when configured with a bad value + fails + when ConsistentQuotesInMultiline is true + and EnforcedStyle is single_quotes + accepts continued strings using all single quotes + registers an offense for strings with line breaks in them + doesn't register offense for double quotes with embedded single + registers an offense for mixed quote styles in a continued string + doesn't register offense for double quotes with interpolation + accepts for double quotes with an escaped normal character + accepts for double quotes with an escaped special character + registers an offense for unneeded double quotes in continuation + doesn't choke on heredocs with inconsistent indentation + and EnforcedStyle is double_quotes + doesn't register offense for single quotes with embedded double + registers an offense for unneeded single quotes in continuation + registers an offense for mixed quote styles in a continued string + accepts continued strings using all double quotes + configured with double quotes preferred + accepts % quotes + accepts single quoted string with backslash + does not accept multiple escaped single quotes in single quotes + accepts single quotes when they are needed + accepts single quotes in string with escaped non-' character + registers offense for opposite + correct + accepts double quotes + accepts heredocs + accepts %q and %Q quotes + registers offense for single quotes when double quotes would be equivalent + accepts escaped single quote in string with escaped non-' character + flags single quotes with plain # (not #@var or #{interpolation} or #$global + registers offense for escaped single quote in single quotes + accepts single quotes in interpolation + accepts single quotes at the start of regexp literals + accepts ' in a %w + can handle a built-in constant parsed as string + configured with single quotes preferred + accepts double quotes when unicode control sequence is used + can handle character literals + registers an offense for words with non-ascii chars + accepts heredocs + registers offense for double quotes when single quotes suffice + accepts double quotes when single quotes are used + does not register an offense for words with non-ascii chars and other control sequences + accepts % quotes + can handle a built-in constant parsed as string + accepts double quotes when control characters are used + accepts double quotes when interpolating & quotes in multiple lines + accepts %q and %Q quotes + accepts double quotes when interpolating an instance variable + accepts double quotes in interpolation + accepts " in a %w + detects unneeded double quotes within concatenated string + registers offense for correct + opposite + accepts double quotes when new line is used + accepts double quotes with some other special symbols + accepts single quotes + accepts single quotes in interpolation + accepts double quotes at the start of regexp literals + accepts double quotes when interpolating a class variable + registers an offense for "\" + accepts double quotes when interpolating a global variable + accepts \\\n in a string + registers an offense for "\"" + +RuboCop::Cop::Lint::SelfAssignment + registers an offense when using shorthand-and var self-assignment + does not register an offense when using constant var assignment for constant from another scope + registers an offense when using class var self-assignment + registers an offense when using multiple var self-assignment through array + does not register an offense when using multiple var assignment through splat + does not register an offense when using class var assignment + does not register an offense when using constant var or-assignment for constant from another scope + does not register an offense when using instance var assignment + does not register an offense when using local var assignment + registers an offense when using shorthand-or var self-assignment + does not register an offense when using shorthand-and var assignment + registers an offense when using instance var self-assignment + registers an offense when using local var self-assignment + does not register an offense when using global var assignment + registers an offense when using constant var self-assignment + does not register an offense when using multiple var assignment + does not register an offense when using multiple var assignment through method call + does not register an offense when using shorthand-or var assignment + registers an offense when using global var self-assignment + registers an offense when using multiple var self-assignment + +RuboCop::Cop::Style::OptionalArguments + registers an offense for each optional argument when multiple optional arguments are followed by a required argument + registers an offense when an optional argument is followed by a required argument + allows methods without arguments + allows methods with multiple optional arguments at the end + allows methods with only required arguments + allows methods with only optional arguments + allows methods with only one optional argument + allows methods with only one required argument + named params + with default values + allows optional arguments before an optional named argument + required params + registers an offense for optional arguments that come before required arguments where there are name arguments + allows optional arguments before required named arguments + allows optional arguments to come before a mix of required and optional named argument + +RuboCop::Cop::Lint::MissingSuper + constructor + does not register an offense for the constructor-like method defined outside of a class + does not register an offense when there is a `super` call + does not register an offense for the class with stateless parent class + registers an offense when no `super` call + does not register an offense for the class without parent class + callbacks + registers an offense when method callback is without `super` call + does not register an offense when callback has a `super` call + registers no offense when module callback without `super` call + registers an offense when class callback without `super` call + registers an offense when class callback within `self << class` and without `super` call + +RuboCop::Cop::Style::IfUnlessModifier + accepts if-end followed by a chained call using `.` + adds parens in autocorrect when if-end used with `||` operator + accepts if-end followed by a chained call using `&.` + accepts code with EOL comment since user might want to keep it + accepts if/elsif + accepts if-else-end + adds parens in autocorrect when if-end used with `&&` operator + accepts if-end when used as LHS of binary arithmetic + when if-end condition has some code after the end keyword + when it is not short enough to fit on a single line + accepts it in the multiline form + when it is short enough to fit on a single line + corrects it to the single-line form + unless-end with conditional as body + accepts + short multiline if near an else etc + registers an offense + with a named regexp capture on the LHS + does not register an offense + behaves like condition modifier cop + for a multiline 'if' + accepts it if single line would not fit on one line + doesn't break when used as RHS of class var assignment + doesn't break when used as RHS of local var assignment + doesn't break when used as RHS of binary arithmetic + handles inline comments during autocorrection + accepts it when condition has local variable assignment + accepts an empty body + doesn't break when used as RHS of constant assignment + corrects it if result fits in one line + corrects it when assignment is in body + doesn't break when used as RHS of instance var assignment + handles one-line usage + accepts it if body spans more than one line + when there is a comment on the first line and some code after the end keyword + does not register an offense + accepts multiline condition in modifier form + registers an offense + when Layout/LineLength is disabled + registers an offense even for a long modifier statement + when Layout/LineLength is disabled + registers an offense even for a long modifier statement + when if-end condition has a first line comment + when it is short enough to fit on a single line + corrects it to the single-line form + when it is not short enough to fit on a single line + accepts it in the multiline form + behaves like condition modifier cop + for a multiline 'unless' + accepts it when condition has local variable assignment + doesn't break when used as RHS of constant assignment + accepts an empty body + corrects it when assignment is in body + doesn't break when used as RHS of class var assignment + accepts it if single line would not fit on one line + doesn't break when used as RHS of local var assignment + handles inline comments during autocorrection + doesn't break when used as RHS of binary arithmetic + corrects it if result fits in one line + handles one-line usage + doesn't break when used as RHS of instance var assignment + accepts it if body spans more than one line + when Layout/LineLength is disabled + registers an offense even for a long modifier statement + accepts multiline condition in modifier form + registers an offense + when there is a comment on the first line and some code after the end keyword + does not register an offense + with implicit match conditional + when a multiline if doesn't fit on one line + accepts + when a multiline if fits on one line + registers an offense + multiline if that fits on one line + registers an offense + and has two statements separated by semicolon + accepts + when if-end condition is a value in a hash + when it is short enough to fit on a single line + corrects it to the single-line form + when it is not short enough to fit on a single line + accepts it in the multiline form + multiline if that fits on one line with comment near end + accepts + multiline unless that fits on one line + registers an offense + when if-end condition is assigned to a variable + with variable being on the same line + when it is short enough to fit on a single line + corrects it to the single-line form + when it is not short enough to fit on a single line + accepts it in the multiline form + with variable being on the previous line + when it is short enough to fit on a single line + corrects it to the single-line form + when it is not short enough to fit on a single line + accepts it in the multiline form + modifier if that does not fit on one line + when Layout/LineLength is disabled in configuration + accepts + when Layout/LineLength is disabled with enable/disable comments + accepts + when Layout/LineLength is disabled with an EOL comment + accepts + when Layout/LineLength is enabled + corrects it to normal form + and the long line is allowed because AllowURI is true + accepts + IgnoreCopDirectives + and the long line is allowed because IgnoreCopDirectives is true + accepts + and the long line is too long because IgnoreCopDirectives is false + registers an offense + when variable assignment is used in the branch body of if modifier + registers an offense + when using a method with heredoc argument + accepts + and the long line is too long because AllowURI is false + registers an offense + if-end is argument to a non-parenthesized method call + adds parentheses so as not to change meaning + with tabs used for indentation + with Layout/IndentationStyle: IndentationWidth config + behaves like with tabs indentation + it doesn't fit on one line + doesn't register an offense + it fits on one line + registers an offense + with Layout/IndentationWidth: Width config + behaves like with tabs indentation + it doesn't fit on one line + doesn't register an offense + it fits on one line + registers an offense + when if-end condition is an element of an array + when not short enough to fit on a single line + accepts it in the multiline form + when short enough to fit on a single line + corrects it to the single-line form + modifier if that does not fit on one line, but is not the only statement on the line + accepts + multiline if that fits on one line with comment on first line + registers an offense and preserves comment + if-end with conditional as body + accepts + if-end is argument to a parenthesized method call + adds parentheses because otherwise it would cause SyntaxError RuboCop::Cop::Style::ConditionalAssignment - allows if elsif else with the same assignment only in if elsif - allows method calls in conditionals - allows assignment to the result of a ternary operation - allows aref assignment with different indices in if..else - allows modifier if inside of if else - allows assignment in multiple branches when it is wrapped in a modifier registers an offense for assignment in if elsif elsif else - doesn't crash with empty braces + registers an offense for assignment in if elsif else + allows assignment using different operators in if else + allows assignment to the result of a ternary operation + allows method calls in conditionals + counts array assignment when determining multiple assignment doesn't crash when assignment statement uses chars which have special meaning in a regex + allows assignment using different operators in if elsif else registers an offense for assignment in case when then else - allows if elsif else with the same assignment only in elsif else - allows assignment of different variables in if else - registers an offense for assignment in if then elsif then else - allows modifier if - allows assignment using different operators in if else - autocorrects assignment in if else when the assignment spans multiple lines - registers an offense for assignment in if elsif else allows different assignment types in case with when else - allows method calls in if else - allows if elsif else with the same assignment only in if else + allows assignment of different variables in case when else + registers an offense for assignment in if then elsif then else registers an offense for assignment in case with when else - allows assignment using different operators in if elsif else - registers an offense for assignment in ternary operation using strings - allows assignment using different (method) operators in if..else registers an offense in an if else if the assignment is already at the line length limit - allows assignment of different variables in case when else - counts array assignment when determining multiple assignment + allows assignment of different variables in if else + doesn't crash with empty braces + allows assignment using different (method) operators in if..else + allows modifier if inside of if else + allows assignment in multiple branches when it is wrapped in a modifier + allows aref assignment with different indices in if..else registers an offense for assignment in unless else + autocorrects assignment in if else when the assignment spans multiple lines + allows if elsif else with the same assignment only in elsif else + allows method calls in if else + registers an offense for assignment in ternary operation using strings allows if else without variable assignment - behaves like all variable types - registers an offense assigning any variable type in if else - allows assignment to the return of case when - allows assignment to the return of a ternary - registers an offense assigning any variable type in ternary - registers an offense assigning any variable type in case when - allows assignment to the return of if else + allows if elsif else with the same assignment only in if else + allows if elsif else with the same assignment only in if elsif + allows modifier if behaves like comparison methods registers an offense for comparison methods in ternary operations with end alignment to keyword - corrects comparison methods in unless else - corrects comparison methods in case when - corrects comparison methods in if elsif else - >= Ruby 2.7 - corrects comparison methods in case in - with end alignment to start_of_line corrects comparison methods in if elsif else corrects comparison methods in unless else corrects comparison methods in case when >= Ruby 2.7 corrects comparison methods in case in - behaves like all variable types - allows assignment to the return of if else - registers an offense assigning any variable type in if else - allows assignment to the return of a ternary - registers an offense assigning any variable type in case when - allows assignment to the return of case when - registers an offense assigning any variable type in ternary - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to keyword - corrects comparison methods in if elsif else - corrects comparison methods in case when - corrects comparison methods in unless else - >= Ruby 2.7 - corrects comparison methods in case in with end alignment to start_of_line - corrects comparison methods in unless else corrects comparison methods in if elsif else + corrects comparison methods in unless else corrects comparison methods in case when >= Ruby 2.7 corrects comparison methods in case in behaves like all assignment types - for a instance variable lval - registers an offense for assignment using ||= in ternary + for a constant lval + registers an offense for assignment using /= in ternary for a class variable lval - registers an offense for assignment using ||= in ternary - with end alignment to keyword - for a instance variable lval - registers an offense for assignment using ||= in if else - registers an offense for assignment using ||= in case when - for a class variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a constant lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a global variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a local variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else + registers an offense for assignment using /= in ternary with end alignment to start_of_line - for a global variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else for a local variable lval - registers an offense for assignment using ||= in if else - registers an offense for assignment using ||= in case when - for a constant lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a class variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a instance variable lval - registers an offense for assignment using ||= in case when - registers an offense for assignment using ||= in if else - for a constant lval - registers an offense for assignment using ||= in ternary - for a local variable lval - registers an offense for assignment using ||= in ternary - for a global variable lval - registers an offense for assignment using ||= in ternary - behaves like all assignment types - with end alignment to start_of_line + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else for a class variable lval - registers an offense for assignment using -= in case when - registers an offense for assignment using -= in if else + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else for a global variable lval - registers an offense for assignment using -= in case when - registers an offense for assignment using -= in if else + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else for a constant lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when - for a local variable lval - registers an offense for assignment using -= in case when - registers an offense for assignment using -= in if else + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else for a instance variable lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when - for a constant lval - registers an offense for assignment using -= in ternary - for a instance variable lval - registers an offense for assignment using -= in ternary + registers an offense for assignment using /= in if else + registers an offense for assignment using /= in case when + for a local variable lval + registers an offense for assignment using /= in ternary with end alignment to keyword - for a constant lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when - for a local variable lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when - for a instance variable lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when for a class variable lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when + registers an offense for assignment using /= in if else + registers an offense for assignment using /= in case when + for a local variable lval + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else for a global variable lval - registers an offense for assignment using -= in if else - registers an offense for assignment using -= in case when - for a local variable lval - registers an offense for assignment using -= in ternary - for a class variable lval - registers an offense for assignment using -= in ternary + registers an offense for assignment using /= in if else + registers an offense for assignment using /= in case when + for a instance variable lval + registers an offense for assignment using /= in case when + registers an offense for assignment using /= in if else + for a constant lval + registers an offense for assignment using /= in if else + registers an offense for assignment using /= in case when + for a instance variable lval + registers an offense for assignment using /= in ternary for a global variable lval - registers an offense for assignment using -= in ternary + registers an offense for assignment using /= in ternary behaves like all assignment types - for a instance variable lval - registers an offense for assignment using **= in ternary - for a local variable lval - registers an offense for assignment using **= in ternary - with end alignment to start_of_line - for a instance variable lval - registers an offense for assignment using **= in if else - registers an offense for assignment using **= in case when + with end alignment to keyword for a local variable lval - registers an offense for assignment using **= in if else - registers an offense for assignment using **= in case when + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else + for a instance variable lval + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else for a constant lval - registers an offense for assignment using **= in case when - registers an offense for assignment using **= in if else + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else for a global variable lval - registers an offense for assignment using **= in if else - registers an offense for assignment using **= in case when - for a class variable lval - registers an offense for assignment using **= in if else - registers an offense for assignment using **= in case when - for a constant lval - registers an offense for assignment using **= in ternary - for a class variable lval - registers an offense for assignment using **= in ternary - with end alignment to keyword + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else for a class variable lval - registers an offense for assignment using **= in case when - registers an offense for assignment using **= in if else - for a instance variable lval - registers an offense for assignment using **= in case when - registers an offense for assignment using **= in if else + registers an offense for assignment using %= in if else + registers an offense for assignment using %= in case when + with end alignment to start_of_line for a constant lval - registers an offense for assignment using **= in case when - registers an offense for assignment using **= in if else - for a global variable lval - registers an offense for assignment using **= in case when - registers an offense for assignment using **= in if else + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else + for a instance variable lval + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else + for a class variable lval + registers an offense for assignment using %= in case when + registers an offense for assignment using %= in if else for a local variable lval - registers an offense for assignment using **= in if else - registers an offense for assignment using **= in case when - for a global variable lval - registers an offense for assignment using **= in ternary - behaves like all assignment types + registers an offense for assignment using %= in if else + registers an offense for assignment using %= in case when + for a global variable lval + registers an offense for assignment using %= in if else + registers an offense for assignment using %= in case when for a instance variable lval - registers an offense for assignment using ^= in ternary + registers an offense for assignment using %= in ternary for a global variable lval - registers an offense for assignment using ^= in ternary + registers an offense for assignment using %= in ternary + for a class variable lval + registers an offense for assignment using %= in ternary for a constant lval - registers an offense for assignment using ^= in ternary + registers an offense for assignment using %= in ternary for a local variable lval + registers an offense for assignment using %= in ternary + behaves like all variable types + registers an offense assigning any variable type in if else + registers an offense assigning any variable type in case when + allows assignment to the return of a ternary + allows assignment to the return of if else + registers an offense assigning any variable type in ternary + allows assignment to the return of case when + behaves like else followed by new conditional without else + allows if elsif else if + behaves like all assignment types + for a constant lval registers an offense for assignment using ^= in ternary - with end alignment to keyword + for a class variable lval + registers an offense for assignment using ^= in ternary + with end alignment to start_of_line for a instance variable lval - registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when - for a class variable lval registers an offense for assignment using ^= in if else + for a class variable lval registers an offense for assignment using ^= in case when - for a local variable lval + registers an offense for assignment using ^= in if else + for a constant lval registers an offense for assignment using ^= in case when registers an offense for assignment using ^= in if else - for a global variable lval + for a local variable lval registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when - for a constant lval + for a global variable lval registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when - for a class variable lval + for a instance variable lval registers an offense for assignment using ^= in ternary - with end alignment to start_of_line + for a local variable lval + registers an offense for assignment using ^= in ternary + for a global variable lval + registers an offense for assignment using ^= in ternary + with end alignment to keyword for a constant lval registers an offense for assignment using ^= in case when registers an offense for assignment using ^= in if else for a class variable lval - registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when + registers an offense for assignment using ^= in if else for a instance variable lval registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when @@ -26378,242 +17693,130 @@ for a global variable lval registers an offense for assignment using ^= in if else registers an offense for assignment using ^= in case when - behaves like else followed by new conditional without else - allows if elsif else if - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to start_of_line - corrects comparison methods in case when - corrects comparison methods in if elsif else - corrects comparison methods in unless else - >= Ruby 2.7 - corrects comparison methods in case in - with end alignment to keyword - corrects comparison methods in if elsif else - corrects comparison methods in case when - corrects comparison methods in unless else - >= Ruby 2.7 - corrects comparison methods in case in - behaves like all variable types - registers an offense assigning any variable type in if else - allows assignment to the return of if else - registers an offense assigning any variable type in case when - allows assignment to the return of a ternary - allows assignment to the return of case when - registers an offense assigning any variable type in ternary - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to start_of_line - corrects comparison methods in if elsif else - corrects comparison methods in unless else - corrects comparison methods in case when - >= Ruby 2.7 - corrects comparison methods in case in - with end alignment to keyword - corrects comparison methods in unless else - corrects comparison methods in case when - corrects comparison methods in if elsif else - >= Ruby 2.7 - corrects comparison methods in case in behaves like all assignment types - for a instance variable lval - registers an offense for assignment using &= in ternary - for a class variable lval + for a local variable lval registers an offense for assignment using &= in ternary for a global variable lval registers an offense for assignment using &= in ternary with end alignment to start_of_line - for a global variable lval + for a class variable lval + registers an offense for assignment using &= in case when registers an offense for assignment using &= in if else + for a local variable lval registers an offense for assignment using &= in case when - for a constant lval registers an offense for assignment using &= in if else + for a global variable lval registers an offense for assignment using &= in case when - for a class variable lval + registers an offense for assignment using &= in if else + for a constant lval registers an offense for assignment using &= in case when registers an offense for assignment using &= in if else for a instance variable lval registers an offense for assignment using &= in if else registers an offense for assignment using &= in case when + with end alignment to keyword for a local variable lval - registers an offense for assignment using &= in if else registers an offense for assignment using &= in case when - for a constant lval - registers an offense for assignment using &= in ternary - for a local variable lval - registers an offense for assignment using &= in ternary - with end alignment to keyword - for a constant lval registers an offense for assignment using &= in if else + for a instance variable lval registers an offense for assignment using &= in case when + registers an offense for assignment using &= in if else for a class variable lval registers an offense for assignment using &= in case when registers an offense for assignment using &= in if else - for a local variable lval - registers an offense for assignment using &= in if else - registers an offense for assignment using &= in case when for a global variable lval registers an offense for assignment using &= in if else registers an offense for assignment using &= in case when - for a instance variable lval + for a constant lval registers an offense for assignment using &= in if else registers an offense for assignment using &= in case when - configured to check conditions with multiple statements - registers an offense for multiple assignment when an earlier assignment is is protected by a modifier - allows assignment in multiple branches when it is wrapped in a modifier - assignment as the last statement - registers an offense in if elsif else with more than variable assignment - registers offense for multiple assignment in unless else - registers an offense in if elsif else with some branches only containing variable assignment and others containing more than variable assignment - registers offense for multiple assignment in if elsif elsif else - registers an offense for multiple assignment in if elsif else - registers an offense in case when else with more than variable assignment - registers an offense in unless else with more than variable assignment - registers an offense in if else with more than variable assignment - register an offense for multiple assignment in if else - registers offense for multiple assignments in case when with only one when - registers offense for multiple assignments in case when with multiple whens - multiple assignment in only one branch - registers an offense when multiple assignment is in elsif - registers an offense when multiple assignment is in else - registers an offense when multiple assignment is in if - behaves like allows out of order multiple assignment in if elsif else - allows out of order multiple assignment in if elsif else - autocorrect - corrects multiple assignment in if elsif else - corrects assignment in an if statement that is nested in unless else - corrects multiple assignment in unless else - corrects multiple assignment in case when with multiple whens - corrects multiple assignment in case when - corrects multiple assignment in if else - corrects multiple assignment in if elsif else with multiple elsifs - behaves like all assignment types - with end alignment to start_of_line - for a local variable lval - registers an offense for assignment using >>= in case when - registers an offense for assignment using >>= in if else - for a global variable lval - registers an offense for assignment using >>= in case when - registers an offense for assignment using >>= in if else - for a constant lval - registers an offense for assignment using >>= in case when - registers an offense for assignment using >>= in if else - for a instance variable lval - registers an offense for assignment using >>= in if else - registers an offense for assignment using >>= in case when - for a class variable lval - registers an offense for assignment using >>= in case when - registers an offense for assignment using >>= in if else - for a local variable lval - registers an offense for assignment using >>= in ternary for a constant lval - registers an offense for assignment using >>= in ternary - with end alignment to keyword - for a constant lval - registers an offense for assignment using >>= in if else - registers an offense for assignment using >>= in case when - for a instance variable lval - registers an offense for assignment using >>= in if else - registers an offense for assignment using >>= in case when - for a global variable lval - registers an offense for assignment using >>= in case when - registers an offense for assignment using >>= in if else - for a class variable lval - registers an offense for assignment using >>= in if else - registers an offense for assignment using >>= in case when - for a local variable lval - registers an offense for assignment using >>= in if else - registers an offense for assignment using >>= in case when - for a class variable lval - registers an offense for assignment using >>= in ternary - for a global variable lval - registers an offense for assignment using >>= in ternary - for a instance variable lval - registers an offense for assignment using >>= in ternary - behaves like all assignment types - for a constant lval - registers an offense for assignment using %= in ternary + registers an offense for assignment using &= in ternary for a class variable lval - registers an offense for assignment using %= in ternary - for a global variable lval - registers an offense for assignment using %= in ternary + registers an offense for assignment using &= in ternary for a instance variable lval - registers an offense for assignment using %= in ternary - for a local variable lval - registers an offense for assignment using %= in ternary - with end alignment to keyword - for a global variable lval - registers an offense for assignment using %= in if else - registers an offense for assignment using %= in case when - for a instance variable lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - for a class variable lval - registers an offense for assignment using %= in if else - registers an offense for assignment using %= in case when - for a local variable lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - for a constant lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - with end alignment to start_of_line - for a class variable lval - registers an offense for assignment using %= in if else - registers an offense for assignment using %= in case when - for a local variable lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - for a instance variable lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - for a constant lval - registers an offense for assignment using %= in case when - registers an offense for assignment using %= in if else - for a global variable lval - registers an offense for assignment using %= in if else - registers an offense for assignment using %= in case when - behaves like all variable types - allows assignment to the return of if else - allows assignment to the return of a ternary - registers an offense assigning any variable type in if else - registers an offense assigning any variable type in ternary - allows assignment to the return of case when - registers an offense assigning any variable type in case when + registers an offense for assignment using &= in ternary behaves like comparison methods registers an offense for comparison methods in ternary operations with end alignment to keyword - corrects comparison methods in case when - corrects comparison methods in if elsif else corrects comparison methods in unless else + corrects comparison methods in if elsif else + corrects comparison methods in case when >= Ruby 2.7 corrects comparison methods in case in with end alignment to start_of_line corrects comparison methods in unless else - corrects comparison methods in case when corrects comparison methods in if elsif else + corrects comparison methods in case when >= Ruby 2.7 corrects comparison methods in case in - IncludeTernaryExpressions false - allows assignment in ternary operation + for if elsif else if else + autocorrects the outer offense later + autocorrects the inner offense first behaves like all assignment types + for a local variable lval + registers an offense for assignment using *= in ternary + for a instance variable lval + registers an offense for assignment using *= in ternary + with end alignment to keyword + for a local variable lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a constant lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a class variable lval + registers an offense for assignment using *= in case when + registers an offense for assignment using *= in if else + for a global variable lval + registers an offense for assignment using *= in case when + registers an offense for assignment using *= in if else + for a instance variable lval + registers an offense for assignment using *= in case when + registers an offense for assignment using *= in if else for a constant lval - registers an offense for assignment using |= in ternary - for a global variable lval - registers an offense for assignment using |= in ternary + registers an offense for assignment using *= in ternary for a class variable lval - registers an offense for assignment using |= in ternary + registers an offense for assignment using *= in ternary + with end alignment to start_of_line + for a class variable lval + registers an offense for assignment using *= in case when + registers an offense for assignment using *= in if else + for a constant lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a instance variable lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a global variable lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a local variable lval + registers an offense for assignment using *= in if else + registers an offense for assignment using *= in case when + for a global variable lval + registers an offense for assignment using *= in ternary + behaves like else followed by new conditional without else + allows if elsif else unless + behaves like all variable types + registers an offense assigning any variable type in case when + registers an offense assigning any variable type in if else + allows assignment to the return of a ternary + registers an offense assigning any variable type in ternary + allows assignment to the return of case when + allows assignment to the return of if else + behaves like all assignment types with end alignment to start_of_line for a local variable lval - registers an offense for assignment using |= in if else registers an offense for assignment using |= in case when - for a class variable lval + registers an offense for assignment using |= in if else + for a instance variable lval registers an offense for assignment using |= in if else registers an offense for assignment using |= in case when - for a constant lval + for a class variable lval registers an offense for assignment using |= in case when registers an offense for assignment using |= in if else - for a instance variable lval + for a constant lval registers an offense for assignment using |= in if else registers an offense for assignment using |= in case when for a global variable lval @@ -26623,3532 +17826,12365 @@ registers an offense for assignment using |= in ternary for a local variable lval registers an offense for assignment using |= in ternary + for a constant lval + registers an offense for assignment using |= in ternary + for a global variable lval + registers an offense for assignment using |= in ternary + for a class variable lval + registers an offense for assignment using |= in ternary with end alignment to keyword - for a instance variable lval - registers an offense for assignment using |= in case when - registers an offense for assignment using |= in if else for a constant lval registers an offense for assignment using |= in case when registers an offense for assignment using |= in if else + for a local variable lval + registers an offense for assignment using |= in if else + registers an offense for assignment using |= in case when for a class variable lval registers an offense for assignment using |= in if else registers an offense for assignment using |= in case when - for a local variable lval + for a instance variable lval registers an offense for assignment using |= in if else registers an offense for assignment using |= in case when for a global variable lval - registers an offense for assignment using |= in case when registers an offense for assignment using |= in if else - behaves like all assignment types + registers an offense for assignment using |= in case when + autocorrect + corrects =~ in ternary operations + preserves comments during correction in case when else + preserves comments during correction in if else + corrects assignment to unbracketed array in if else + constant assignment + corrects if..else with namespaced constant + corrects if..else with top-level constant + multiple assignment + does not register an offense in if else + does not register an offense in case when + assignment from a method + corrects unless else + corrects case when + corrects if else + aref assignment + corrects if..else + with different indices + doesn't register an offense + self.attribute= assignment + corrects if..else + with different receivers + doesn't register an offense + empty branch + allows assignment in case when without an else + allows an empty elsif statement + allows an empty if statement + allows an empty when branch with an else + allows case with an empty else + allows assignment in if without an else + allows if elsif without else + allows assignment in unless without an else + behaves like comparison methods + registers an offense for comparison methods in ternary operations + with end alignment to start_of_line + corrects comparison methods in case when + corrects comparison methods in unless else + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to keyword + corrects comparison methods in if elsif else + corrects comparison methods in case when + corrects comparison methods in unless else + >= Ruby 2.7 + corrects comparison methods in case in + with nested conditionals + does not consider branches of nested ifs + eventually autocorrects all branches + behaves like comparison methods + registers an offense for comparison methods in ternary operations + with end alignment to start_of_line + corrects comparison methods in unless else + corrects comparison methods in case when + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to keyword + corrects comparison methods in case when + corrects comparison methods in unless else + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + behaves like comparison methods + registers an offense for comparison methods in ternary operations + with end alignment to keyword + corrects comparison methods in unless else + corrects comparison methods in case when + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to start_of_line + corrects comparison methods in unless else + corrects comparison methods in if elsif else + corrects comparison methods in case when + >= Ruby 2.7 + corrects comparison methods in case in + IncludeTernaryExpressions false + allows assignment in ternary operation + behaves like comparison methods + registers an offense for comparison methods in ternary operations + with end alignment to keyword + corrects comparison methods in unless else + corrects comparison methods in case when + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to start_of_line + corrects comparison methods in unless else + corrects comparison methods in case when + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + behaves like comparison methods + registers an offense for comparison methods in ternary operations with end alignment to keyword + corrects comparison methods in unless else + corrects comparison methods in if elsif else + corrects comparison methods in case when + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to start_of_line + corrects comparison methods in case when + corrects comparison methods in unless else + corrects comparison methods in if elsif else + >= Ruby 2.7 + corrects comparison methods in case in + correction would exceed max line length + allows assignment to the same variable in if else if the correction would create a line longer than the configured LineLength + allows assignment to the same variable in if else if the correction would cause the condition to exceed the configured LineLength + allows assignment to the same variable in case when else if the correction would create a line longer than the configured LineLength + behaves like all assignment types + for a class variable lval + registers an offense for assignment using = in ternary + with end alignment to start_of_line for a instance variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when for a local variable lval - registers an offense for assignment using *= in case when - registers an offense for assignment using *= in if else - for a global variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when - for a class variable lval - registers an offense for assignment using *= in case when - registers an offense for assignment using *= in if else + registers an offense for assignment using = in case when + registers an offense for assignment using = in if else for a constant lval - registers an offense for assignment using *= in case when - registers an offense for assignment using *= in if else - for a instance variable lval - registers an offense for assignment using *= in ternary - for a global variable lval - registers an offense for assignment using *= in ternary - for a class variable lval - registers an offense for assignment using *= in ternary - for a local variable lval - registers an offense for assignment using *= in ternary - for a constant lval - registers an offense for assignment using *= in ternary - with end alignment to start_of_line + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when for a global variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when for a class variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when - for a local variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when + registers an offense for assignment using = in case when + registers an offense for assignment using = in if else + for a constant lval + registers an offense for assignment using = in ternary + for a local variable lval + registers an offense for assignment using = in ternary + for a global variable lval + registers an offense for assignment using = in ternary + for a instance variable lval + registers an offense for assignment using = in ternary + with end alignment to keyword for a constant lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when for a instance variable lval - registers an offense for assignment using *= in if else - registers an offense for assignment using *= in case when + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when + for a local variable lval + registers an offense for assignment using = in if else + registers an offense for assignment using = in case when + for a class variable lval + registers an offense for assignment using = in case when + registers an offense for assignment using = in if else + for a global variable lval + registers an offense for assignment using = in case when + registers an offense for assignment using = in if else assignment as the last statement - allows multiple assignments in case when if there are uniq variables in the when branches - allows more than variable assignment in if else + allows variable assignment in case when else with more than variable assignment allows variable assignment in unless else with more than variable assignment - allows multiple assignment in if elsif else - allows multiple assignment in if elsif elsif else + allows more than variable assignment in if elsif else allows multiple assignment in case when else when the last assignment is the same and the earlier assignments do not appear in all branches allows multiple assignment in if elsif else when the last assignment is the same and the earlier assignments do not appear in all branches + allows more than variable assignment in if else + allows multiple assignment in if elsif elsif else allows multiple assignment in if else allows multiple assignments in case when with only one when - allows variable assignment in case when else with more than variable assignment - allows more than variable assignment in if elsif else - allows assignment in if elsif else with some branches only containing variable assignment and others containing more than variable assignment + allows multiple assignment in if elsif else + allows multiple assignment in unless else allows multiple assignment in case statements when the last assignment is the same and the earlier assignments do not appear in all branches + allows assignment in if elsif else with some branches only containing variable assignment and others containing more than variable assignment allows multiple assignments in case when with multiple whens - allows multiple assignment in unless else + allows multiple assignments in case when if there are uniq variables in the when branches + behaves like allows out of order multiple assignment in if elsif else + allows out of order multiple assignment in if elsif else multiple assignment in only one branch does not register an offense when multiple assignment is in else allows multiple assignment is in elsif allows multiple assignment is in if - behaves like allows out of order multiple assignment in if elsif else - allows out of order multiple assignment in if elsif else behaves like all variable types + allows assignment to the return of a ternary + allows assignment to the return of if else registers an offense assigning any variable type in case when + registers an offense assigning any variable type in if else + registers an offense assigning any variable type in ternary allows assignment to the return of case when + behaves like all variable types + registers an offense assigning any variable type in if else + allows assignment to the return of a ternary + allows assignment to the return of case when + registers an offense assigning any variable type in ternary + registers an offense assigning any variable type in case when + allows assignment to the return of if else + behaves like all assignment types + with end alignment to start_of_line + for a constant lval + registers an offense for assignment using += in case when + registers an offense for assignment using += in if else + for a global variable lval + registers an offense for assignment using += in case when + registers an offense for assignment using += in if else + for a class variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a local variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a instance variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a local variable lval + registers an offense for assignment using += in ternary + with end alignment to keyword + for a instance variable lval + registers an offense for assignment using += in case when + registers an offense for assignment using += in if else + for a class variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a global variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a constant lval + registers an offense for assignment using += in case when + registers an offense for assignment using += in if else + for a local variable lval + registers an offense for assignment using += in if else + registers an offense for assignment using += in case when + for a class variable lval + registers an offense for assignment using += in ternary + for a global variable lval + registers an offense for assignment using += in ternary + for a constant lval + registers an offense for assignment using += in ternary + for a instance variable lval + registers an offense for assignment using += in ternary + behaves like all variable types allows assignment to the return of a ternary allows assignment to the return of if else + registers an offense assigning any variable type in if else + registers an offense assigning any variable type in case when + registers an offense assigning any variable type in ternary + allows assignment to the return of case when + behaves like all assignment types + for a local variable lval + registers an offense for assignment using -= in ternary + for a global variable lval + registers an offense for assignment using -= in ternary + for a class variable lval + registers an offense for assignment using -= in ternary + with end alignment to keyword + for a local variable lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + for a global variable lval + registers an offense for assignment using -= in if else + registers an offense for assignment using -= in case when + for a constant lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + for a class variable lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + for a instance variable lval + registers an offense for assignment using -= in if else + registers an offense for assignment using -= in case when + for a constant lval + registers an offense for assignment using -= in ternary + for a instance variable lval + registers an offense for assignment using -= in ternary + with end alignment to start_of_line + for a global variable lval + registers an offense for assignment using -= in if else + registers an offense for assignment using -= in case when + for a instance variable lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + for a constant lval + registers an offense for assignment using -= in if else + registers an offense for assignment using -= in case when + for a class variable lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + for a local variable lval + registers an offense for assignment using -= in case when + registers an offense for assignment using -= in if else + configured to check conditions with multiple statements + allows assignment in multiple branches when it is wrapped in a modifier + registers an offense for multiple assignment when an earlier assignment is is protected by a modifier + autocorrect + corrects multiple assignment in case when + corrects multiple assignment in if elsif else with multiple elsifs + corrects assignment in an if statement that is nested in unless else + corrects multiple assignment in if else + corrects multiple assignment in unless else + corrects multiple assignment in case when with multiple whens + corrects multiple assignment in if elsif else + assignment as the last statement + registers an offense in if elsif else with more than variable assignment + registers offense for multiple assignment in unless else + register an offense for multiple assignment in if else + registers offense for multiple assignments in case when with multiple whens + registers an offense in case when else with more than variable assignment + registers an offense in if elsif else with some branches only containing variable assignment and others containing more than variable assignment + registers an offense in unless else with more than variable assignment + registers an offense in if else with more than variable assignment + registers offense for multiple assignment in if elsif elsif else + registers an offense for multiple assignment in if elsif else + registers offense for multiple assignments in case when with only one when + behaves like allows out of order multiple assignment in if elsif else + allows out of order multiple assignment in if elsif else + multiple assignment in only one branch + registers an offense when multiple assignment is in else + registers an offense when multiple assignment is in if + registers an offense when multiple assignment is in elsif + behaves like all variable types registers an offense assigning any variable type in ternary + allows assignment to the return of a ternary registers an offense assigning any variable type in if else + registers an offense assigning any variable type in case when + allows assignment to the return of if else + allows assignment to the return of case when behaves like comparison methods registers an offense for comparison methods in ternary operations with end alignment to start_of_line corrects comparison methods in if elsif else - corrects comparison methods in unless else corrects comparison methods in case when + corrects comparison methods in unless else >= Ruby 2.7 corrects comparison methods in case in with end alignment to keyword corrects comparison methods in if elsif else - corrects comparison methods in unless else corrects comparison methods in case when + corrects comparison methods in unless else >= Ruby 2.7 corrects comparison methods in case in behaves like all assignment types - for a instance variable lval - registers an offense for assignment using &&= in ternary - for a local variable lval - registers an offense for assignment using &&= in ternary - for a global variable lval - registers an offense for assignment using &&= in ternary - for a constant lval - registers an offense for assignment using &&= in ternary - for a class variable lval - registers an offense for assignment using &&= in ternary with end alignment to keyword - for a class variable lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when - for a constant lval - registers an offense for assignment using &&= in case when - registers an offense for assignment using &&= in if else - for a global variable lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when - for a local variable lval - registers an offense for assignment using &&= in case when - registers an offense for assignment using &&= in if else - for a instance variable lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when - with end alignment to start_of_line - for a constant lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when - for a global variable lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when for a local variable lval - registers an offense for assignment using &&= in if else - registers an offense for assignment using &&= in case when - for a class variable lval - registers an offense for assignment using &&= in case when - registers an offense for assignment using &&= in if else - for a instance variable lval - registers an offense for assignment using &&= in case when - registers an offense for assignment using &&= in if else - behaves like all assignment types - for a class variable lval - registers an offense for assignment using << in ternary - for a constant lval - registers an offense for assignment using << in ternary - for a local variable lval - registers an offense for assignment using << in ternary - for a global variable lval - registers an offense for assignment using << in ternary - with end alignment to start_of_line - for a class variable lval - registers an offense for assignment using << in case when registers an offense for assignment using << in if else + registers an offense for assignment using << in case when for a constant lval registers an offense for assignment using << in if else registers an offense for assignment using << in case when - for a global variable lval + for a instance variable lval registers an offense for assignment using << in if else registers an offense for assignment using << in case when - for a local variable lval + for a global variable lval registers an offense for assignment using << in if else registers an offense for assignment using << in case when - for a instance variable lval - registers an offense for assignment using << in case when + for a class variable lval registers an offense for assignment using << in if else + registers an offense for assignment using << in case when + for a class variable lval + registers an offense for assignment using << in ternary for a instance variable lval registers an offense for assignment using << in ternary - with end alignment to keyword + with end alignment to start_of_line for a global variable lval - registers an offense for assignment using << in case when registers an offense for assignment using << in if else + registers an offense for assignment using << in case when for a instance variable lval registers an offense for assignment using << in case when registers an offense for assignment using << in if else for a local variable lval - registers an offense for assignment using << in if else registers an offense for assignment using << in case when + registers an offense for assignment using << in if else for a constant lval registers an offense for assignment using << in case when registers an offense for assignment using << in if else for a class variable lval - registers an offense for assignment using << in case when registers an offense for assignment using << in if else - behaves like all assignment types + registers an offense for assignment using << in case when + for a constant lval + registers an offense for assignment using << in ternary for a global variable lval - registers an offense for assignment using /= in ternary - for a class variable lval - registers an offense for assignment using /= in ternary + registers an offense for assignment using << in ternary for a local variable lval - registers an offense for assignment using /= in ternary - with end alignment to keyword - for a local variable lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - for a class variable lval - registers an offense for assignment using /= in if else - registers an offense for assignment using /= in case when - for a global variable lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - for a constant lval - registers an offense for assignment using /= in if else - registers an offense for assignment using /= in case when - for a instance variable lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - with end alignment to start_of_line - for a class variable lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - for a constant lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - for a local variable lval - registers an offense for assignment using /= in if else - registers an offense for assignment using /= in case when - for a instance variable lval - registers an offense for assignment using /= in if else - registers an offense for assignment using /= in case when - for a global variable lval - registers an offense for assignment using /= in case when - registers an offense for assignment using /= in if else - for a constant lval - registers an offense for assignment using /= in ternary - for a instance variable lval - registers an offense for assignment using /= in ternary - behaves like all variable types - registers an offense assigning any variable type in ternary - allows assignment to the return of if else - allows assignment to the return of case when - registers an offense assigning any variable type in if else - allows assignment to the return of a ternary - registers an offense assigning any variable type in case when + registers an offense for assignment using << in ternary EndAlignment configured to start_of_line autocorrect - uses proper end alignment in unless - uses proper end alignment in if uses proper end alignment in case + uses proper end alignment in if + uses proper end alignment in unless behaves like comparison methods registers an offense for comparison methods in ternary operations with end alignment to keyword - corrects comparison methods in case when corrects comparison methods in unless else + corrects comparison methods in case when corrects comparison methods in if elsif else >= Ruby 2.7 corrects comparison methods in case in with end alignment to start_of_line corrects comparison methods in unless else - corrects comparison methods in if elsif else - corrects comparison methods in case when - >= Ruby 2.7 - corrects comparison methods in case in - autocorrect - corrects assignment to unbracketed array in if else - preserves comments during correction in case when else - corrects =~ in ternary operations - preserves comments during correction in if else - aref assignment - corrects if..else - with different indices - doesn't register an offense - assignment from a method - corrects case when - corrects if else - corrects unless else - self.attribute= assignment - corrects if..else - with different receivers - doesn't register an offense - constant assignment - corrects if..else with top-level constant - corrects if..else with namespaced constant - multiple assignment - does not register an offense in if else - does not register an offense in case when - empty branch - allows assignment in if without an else - allows an empty elsif statement - allows if elsif without else - allows an empty when branch with an else - allows assignment in unless without an else - allows case with an empty else - allows assignment in case when without an else - allows an empty if statement - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to keyword corrects comparison methods in case when - corrects comparison methods in unless else - corrects comparison methods in if elsif else - >= Ruby 2.7 - corrects comparison methods in case in - with end alignment to start_of_line corrects comparison methods in if elsif else - corrects comparison methods in case when - corrects comparison methods in unless else >= Ruby 2.7 corrects comparison methods in case in behaves like all assignment types - with end alignment to start_of_line - for a local variable lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else - for a class variable lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else - for a instance variable lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else - for a constant lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else - for a global variable lval - registers an offense for assignment using += in if else - registers an offense for assignment using += in case when + for a local variable lval + registers an offense for assignment using >>= in ternary for a global variable lval - registers an offense for assignment using += in ternary + registers an offense for assignment using >>= in ternary + for a class variable lval + registers an offense for assignment using >>= in ternary with end alignment to keyword - for a class variable lval - registers an offense for assignment using += in if else - registers an offense for assignment using += in case when + for a local variable lval + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when for a instance variable lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when + for a global variable lval + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when for a constant lval - registers an offense for assignment using += in case when - registers an offense for assignment using += in if else + registers an offense for assignment using >>= in case when + registers an offense for assignment using >>= in if else + for a class variable lval + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when + with end alignment to start_of_line for a local variable lval - registers an offense for assignment using += in if else - registers an offense for assignment using += in case when + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when + for a class variable lval + registers an offense for assignment using >>= in case when + registers an offense for assignment using >>= in if else + for a instance variable lval + registers an offense for assignment using >>= in case when + registers an offense for assignment using >>= in if else for a global variable lval - registers an offense for assignment using += in if else - registers an offense for assignment using += in case when - for a instance variable lval - registers an offense for assignment using += in ternary - for a class variable lval - registers an offense for assignment using += in ternary + registers an offense for assignment using >>= in if else + registers an offense for assignment using >>= in case when + for a constant lval + registers an offense for assignment using >>= in case when + registers an offense for assignment using >>= in if else for a constant lval - registers an offense for assignment using += in ternary - for a local variable lval - registers an offense for assignment using += in ternary + registers an offense for assignment using >>= in ternary + for a instance variable lval + registers an offense for assignment using >>= in ternary behaves like all assignment types - with end alignment to keyword + with end alignment to start_of_line + for a local variable lval + registers an offense for assignment using <<= in case when + registers an offense for assignment using <<= in if else for a constant lval registers an offense for assignment using <<= in if else registers an offense for assignment using <<= in case when - for a class variable lval - registers an offense for assignment using <<= in case when - registers an offense for assignment using <<= in if else for a instance variable lval registers an offense for assignment using <<= in if else registers an offense for assignment using <<= in case when - for a local variable lval - registers an offense for assignment using <<= in if else + for a class variable lval registers an offense for assignment using <<= in case when + registers an offense for assignment using <<= in if else for a global variable lval registers an offense for assignment using <<= in case when registers an offense for assignment using <<= in if else for a global variable lval registers an offense for assignment using <<= in ternary - for a local variable lval - registers an offense for assignment using <<= in ternary - with end alignment to start_of_line + with end alignment to keyword for a class variable lval registers an offense for assignment using <<= in if else registers an offense for assignment using <<= in case when for a global variable lval registers an offense for assignment using <<= in if else registers an offense for assignment using <<= in case when - for a local variable lval - registers an offense for assignment using <<= in if else + for a constant lval registers an offense for assignment using <<= in case when - for a instance variable lval registers an offense for assignment using <<= in if else + for a local variable lval registers an offense for assignment using <<= in case when - for a constant lval + registers an offense for assignment using <<= in if else + for a instance variable lval registers an offense for assignment using <<= in if else registers an offense for assignment using <<= in case when for a constant lval registers an offense for assignment using <<= in ternary - for a class variable lval + for a local variable lval registers an offense for assignment using <<= in ternary for a instance variable lval registers an offense for assignment using <<= in ternary - behaves like else followed by new conditional without else - allows if elsif else unless - correction would exceed max line length - allows assignment to the same variable in if else if the correction would cause the condition to exceed the configured LineLength - allows assignment to the same variable in case when else if the correction would create a line longer than the configured LineLength - allows assignment to the same variable in if else if the correction would create a line longer than the configured LineLength + for a class variable lval + registers an offense for assignment using <<= in ternary + behaves like comparison methods + registers an offense for comparison methods in ternary operations + with end alignment to keyword + corrects comparison methods in if elsif else + corrects comparison methods in unless else + corrects comparison methods in case when + >= Ruby 2.7 + corrects comparison methods in case in + with end alignment to start_of_line + corrects comparison methods in unless else + corrects comparison methods in if elsif else + corrects comparison methods in case when + >= Ruby 2.7 + corrects comparison methods in case in + behaves like all assignment types + for a constant lval + registers an offense for assignment using &&= in ternary + for a class variable lval + registers an offense for assignment using &&= in ternary + with end alignment to keyword + for a class variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a global variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a local variable lval + registers an offense for assignment using &&= in case when + registers an offense for assignment using &&= in if else + for a constant lval + registers an offense for assignment using &&= in case when + registers an offense for assignment using &&= in if else + for a instance variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a local variable lval + registers an offense for assignment using &&= in ternary + with end alignment to start_of_line + for a local variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a constant lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a class variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a global variable lval + registers an offense for assignment using &&= in case when + registers an offense for assignment using &&= in if else + for a instance variable lval + registers an offense for assignment using &&= in if else + registers an offense for assignment using &&= in case when + for a global variable lval + registers an offense for assignment using &&= in ternary + for a instance variable lval + registers an offense for assignment using &&= in ternary behaves like all variable types - allows assignment to the return of if else + allows assignment to the return of case when + registers an offense assigning any variable type in case when registers an offense assigning any variable type in if else + allows assignment to the return of if else allows assignment to the return of a ternary - allows assignment to the return of case when registers an offense assigning any variable type in ternary - registers an offense assigning any variable type in case when - with nested conditionals - does not consider branches of nested ifs - eventually autocorrects all branches - for if elsif else if else - autocorrects the inner offense first - autocorrects the outer offense later behaves like all assignment types + for a class variable lval + registers an offense for assignment using **= in ternary with end alignment to keyword for a global variable lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when - for a local variable lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when + registers an offense for assignment using **= in case when + registers an offense for assignment using **= in if else for a constant lval - registers an offense for assignment using = in case when - registers an offense for assignment using = in if else + registers an offense for assignment using **= in case when + registers an offense for assignment using **= in if else + for a local variable lval + registers an offense for assignment using **= in if else + registers an offense for assignment using **= in case when for a class variable lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when + registers an offense for assignment using **= in case when + registers an offense for assignment using **= in if else for a instance variable lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when + registers an offense for assignment using **= in case when + registers an offense for assignment using **= in if else + for a constant lval + registers an offense for assignment using **= in ternary for a instance variable lval - registers an offense for assignment using = in ternary + registers an offense for assignment using **= in ternary for a global variable lval - registers an offense for assignment using = in ternary + registers an offense for assignment using **= in ternary + with end alignment to start_of_line + for a constant lval + registers an offense for assignment using **= in case when + registers an offense for assignment using **= in if else + for a class variable lval + registers an offense for assignment using **= in if else + registers an offense for assignment using **= in case when + for a global variable lval + registers an offense for assignment using **= in if else + registers an offense for assignment using **= in case when + for a instance variable lval + registers an offense for assignment using **= in if else + registers an offense for assignment using **= in case when + for a local variable lval + registers an offense for assignment using **= in if else + registers an offense for assignment using **= in case when for a local variable lval - registers an offense for assignment using = in ternary - for a class variable lval - registers an offense for assignment using = in ternary + registers an offense for assignment using **= in ternary + behaves like all assignment types for a constant lval - registers an offense for assignment using = in ternary + registers an offense for assignment using ||= in ternary with end alignment to start_of_line - for a global variable lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when for a class variable lval - registers an offense for assignment using = in case when - registers an offense for assignment using = in if else - for a instance variable lval - registers an offense for assignment using = in case when - registers an offense for assignment using = in if else + registers an offense for assignment using ||= in case when + registers an offense for assignment using ||= in if else for a constant lval - registers an offense for assignment using = in if else - registers an offense for assignment using = in case when + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when + for a global variable lval + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when + for a instance variable lval + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when for a local variable lval - registers an offense for assignment using = in case when - registers an offense for assignment using = in if else - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to start_of_line - corrects comparison methods in if elsif else - corrects comparison methods in unless else - corrects comparison methods in case when - >= Ruby 2.7 - corrects comparison methods in case in - with end alignment to keyword - corrects comparison methods in if elsif else - corrects comparison methods in unless else - corrects comparison methods in case when - >= Ruby 2.7 - corrects comparison methods in case in - behaves like comparison methods - registers an offense for comparison methods in ternary operations - with end alignment to start_of_line - corrects comparison methods in case when - corrects comparison methods in if elsif else - corrects comparison methods in unless else - >= Ruby 2.7 - corrects comparison methods in case in + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when + for a global variable lval + registers an offense for assignment using ||= in ternary + for a instance variable lval + registers an offense for assignment using ||= in ternary + for a class variable lval + registers an offense for assignment using ||= in ternary + for a local variable lval + registers an offense for assignment using ||= in ternary with end alignment to keyword - corrects comparison methods in unless else - corrects comparison methods in case when - corrects comparison methods in if elsif else - >= Ruby 2.7 - corrects comparison methods in case in + for a instance variable lval + registers an offense for assignment using ||= in case when + registers an offense for assignment using ||= in if else + for a class variable lval + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when + for a constant lval + registers an offense for assignment using ||= in case when + registers an offense for assignment using ||= in if else + for a global variable lval + registers an offense for assignment using ||= in case when + registers an offense for assignment using ||= in if else + for a local variable lval + registers an offense for assignment using ||= in if else + registers an offense for assignment using ||= in case when -RuboCop::Cop::Naming::MethodParameterName - registers offense when parameter ends in number on class method - does not register offense for valid parameter names on self.method - does not register for method without parameters - registers offense when parameter is less than minimum length - does not register offense for empty kwrestarg - does not register offense for valid default parameters - does not register offense for valid keyword parameters - registers offense for offensive default parameter - registers offense when parameter contains uppercase characters - can register multiple offenses in one method definition - does not register offense for empty restarg - does not register offense for valid parameter names - registers offense for offensive keyword parameters - registers offense when parameter ends in number - registers offense when parameter with prefix is less than minimum length - with AllowedNames - accepts param names prefixed with underscore - accepts underscore param names - registers unlisted offensive names - accepts specified block param names - when using argument forwarding - does not register an offense - with ForbiddenNames - accepts parameter that uses a forbidden name's letters - registers offense for parameter listed as forbidden - with AllowNamesEndingInNumbers - accept parameters that end in numbers +RuboCop::Cop::Layout::MultilineAssignmentLayout + new_line style + allows multi-line assignments on separate lines + ignores arrays + registers an offense when the rhs is on the same line + registers an offense for masgn with multi-line lhs + registers an offense when the rhs is on the same line in []= + registers an offense when the rhs is on the same line in setters + configured supported types + allows supported types to be configured + when supported types is block + allows multi-line assignments when using block definition on separate lines + allows multi-line assignments when using shovel operator + registers an offense when multi-line assignments using block definition is on the same line + allows multi-line block defines on separate lines + same_line style + registers an offense when the rhs is a different line in []= + registers an offense when the rhs is a different line + registers an offense when the rhs is a different line in setters + ignores arrays + allows multi-line assignments on the same line + registers an offense for masgn with multi-line lhs + when supported types is block + allows when multi-line assignments using block definition is on the same line + allows multi-line assignments when using shovel operator + registers an offense when multi-line assignments using block definition on separate lines + allows multi-line block defines on separate lines + configured supported types + allows supported types to be configured -RuboCop::Cop::Style::RedundantSelfAssignment - does not register an offense when assigning to attribute of `self` the result from other object - does not register an offense when there is no a receiver - registers an offense and corrects when assigning to attribute of non `self` - registers an offense and corrects when assigning to attribute of `self` - does not register an offense when lhs and receiver are different - when lhs and receiver are the same - registers an offense and corrects when assigning to local variable - registers an offense and corrects when assigning to class variable - registers an offense and corrects when assigning to global variable - registers an offense and corrects when assigning to instance variable +RuboCop::Cop::Lint::RedundantStringCoercion + registers an offense and corrects `to_s` in interpolation + accepts interpolation without #to_s + registers an offense and corrects an implicit receiver + accepts #to_s with arguments in an interpolation + registers an offense and corrects `to_s` in an interpolation with several expressions + does not explode on empty interpolation -RuboCop::Cop::Lint::UselessAssignment - when there's an unreferenced assignment in top level if branch while the variable is referenced in the paired else branch - registers an offense for the assignment in the if branch - when a method argument is reassigned and zero arity super is called - accepts - when a setter is invoked with operator assignment in loop body - accepts - when a optional keyword method argument is not used - accepts - when a variable is assigned first with ||= and referenced - accepts - when a variable is reassigned at the end of loop body and would be referenced in loop condition - accepts - when a variable is assigned in main body of begin with rescue but unreferenced - registers an offense - when a variable is reassigned in single branch if and referenced in the branch - registers an offense for the unreferenced assignment - when a splat method argument is not used - accepts - when a block argument is not used - accepts - when an unreferenced variable is reassigned and re-referenced - registers an offense for the unreferenced assignment - when an assignment in a if branch is referenced in another if branch - accepts - when a variable is reassigned while referencing itself in rhs and referenced - accepts - when a variable is assigned in main body of begin, rescue and else then referenced after the begin - accepts - when a variable is assigned and unreferenced in a singleton class - registers an offense - when a named capture is referenced - accepts - when a referenced variable is reassigned but not re-referenced - registers an offense for the non-re-referenced assignment - when a variable is assigned in each branch of if and referenced in the else branch - registers an offense for the assignment in the if branch - when a variable is assigned in main body of begin, rescue and else and reassigned in ensure then referenced after the begin - registers offenses for each assignment before ensure - when a variable is assigned in branch of modifier if that references the variable in its conditional clauseand referenced after the branching - accepts - when a unreferenced variable is reassigned on the left side of && and referenced after the && - registers an offense for the unreferenced assignment - when a variable is assigned in loop body and unreferenced - registers an offense - when a variable is reassigned in single branch if and referenced after the branching - accepts - when a rescued error variable is wrongly tried to be referenced in another rescue body - registers an offense - when a local variable is unreferenced and zero arity super is called - registers an offense - when a variable is reassigned with logical operator assignment and referenced - accepts - when a variable is reassigned with multiple assignment while referencing itself in rhs and referenced - accepts - when a variable is assigned in begin and referenced outside - accepts - when a variable is assigned with ||= before the last expression of the scope - registers an offense - when there's an unreferenced reassignment in a if branch while the variable is referenced in the paired elsif branch - registers an offense for the reassignment in the if branch - when a keyword splat method argument is not used - accepts - when a named capture is unreferenced in top level - registers an offense - when a variable is assigned and passed to a method followed by method taking block - accepts - when a variable is assigned on each side of && and referenced after the && - accepts - inside a `case-match` node - does not register an offense when the variable is used - when a variable is assigned in each branch of if and referenced after the branching - accepts - when a variable is assigned and unreferenced in a module - registers an offense - when there's an unreferenced reassignment in a if branch while the variable is referenced in a case branch in the paired else branch - registers an offense for the reassignment in the if branch - when a block local variable is assigned and unreferenced - registers offenses for the assignment - when a referenced variable is reassigned but not re-referenced in a method defined in loop - registers an offense - when a variable is reassigned and unreferenced in a if branch while the variable is referenced in the paired else branch - registers an offense for the reassignment in the if branch - when a method argument is not used - accepts - when a block local variable is declared but not assigned - accepts - when a keyword splat method argument is used - accepts - when a variable is not used and the name starts with _ - accepts - when a variable is reassigned in loop body but won't be referenced either next iteration or loop condition - registers an offense (PENDING: Requires an advanced logic that checks whether the return value of an operator assignment is used or not.) - when a variable is assigned in loop body and referenced in post while condition - accepts - when a variable is assigned with ||= at the last expression of the scope - registers an offense - when a variable is assigned and unreferenced in a singleton method defined with variable name - registers an offense - when there is only one AST node and it is unused variable - registers an offense - when a variable is referenced in rhs of named capture expression - accepts - when a variable is reassigned multiple times in ensure with rescue then referenced after the begin - registers an offense - when a variable is assigned and unreferenced in a method - registers an offense - when a variable is assigned in 2 identical if branches - doesn't think 1 of the 2 assignments is useless - when a variable is assigned multiple times but unreferenced - registers offenses for each assignment - when a variable is assigned with multiple assignment and unreferenced - registers an offense - when an anonymous keyword splat method argument is defined - accepts - when a variable is assigned and referenced when defining a module - does not register an offense - when a variable is reassigned at the end of loop body and would be referenced in next iteration - accepts - when a variable is assigned and unreferenced in top level - registers an offense - when a variable that has same name as outer scope variable is not referenced in a method defined in loop - registers an offense - when a variable is reassigned multiple times in rescue with ensure then referenced after the begin - registers an offense - when a variable is assigned with operator assignment in rescue and would be referenced with retry - accepts - when a method argument is reassigned but not passed to super - registers an offense - similar name suggestion - when there's a similar method invocation with explicit receiver - does not suggest any name - when there are only less similar names - does not suggest any name - when there's a similar variable-like method invocation - suggests the method name - when there's a similar variable - suggests the variable name - when there's a similar name but it's in inner scope - does not suggest any name - when there's a similar method invocation with arguments - does not suggest any name - when a variable is assigned at the end of rescue and would be referenced with retry - accepts - when a variable is reassigned in a loop - for loop - accepts - post until loop - accepts - while loop - accepts - post while loop - accepts - until loop - accepts - when a named capture is unreferenced in other than top level - registers an offense - when a referenced variable is reassigned in a block - accepts - when an optional method argument is not used - accepts - when a block method argument is not used - accepts - when an unreferenced variable is reassigned in a block - accepts - when a variable is assigned with operator assignment in top level - registers an offense - when a variable is assigned and assigned again in a modifier condition - accepts without parentheses - accepts with parentheses - when a variable is reassigned with binary operator assignment and referenced - accepts - when a unreferenced variable is reassigned on the right side of && and referenced after the && - accepts - when a variable is shadowed by a block argument and unreferenced - registers an offense - when a variable is assigned and unreferenced in a class - registers an offense - when a variable is reassigned with binary operator assignment while assigning to itself in rhs then referenced - registers an offense for the assignment in rhs - when a variable is reassigned multiple times in main body of begin then referenced in rescue - accepts - when a variable is assigned and unreferenced in a singleton method defined with self keyword - registers an offense - when a variable is assigned and unreferenced in a class subclassing another class stored in local variable - registers an offense - when a variable is assigned in single branch if and unreferenced - registers an offense - when a unreferenced variable is reassigned in same branch and referenced after the branching - registers an offense for the unreferenced assignment - when a variable is reassigned multiple times in main body of begin then referenced in ensure - accepts - when a variable is assigned while being passed to a method taking block - and the variable is not used - registers an offense - and the variable is used - accepts - when a variable is reassigned multiple times in main body of begin then referenced after the begin - accepts - when a variable is assigned in loop body and referenced in post until condition - accepts - when a variable is assigned in branch of modifier if that references the variable in its conditional clauseand unreferenced - registers an offense - when a variable is reassigned multiple times in rescue and referenced after the begin - registers an offense +RuboCop::Cop::Layout::SpaceAroundBlockParameters + when EnforcedStyleInsidePipes is no_space + registers an offense and corrects all types of spacing issues + accepts a block parameter without preceding space + accepts a lambda with spaces in the right places + registers an offense and corrects space after last parameter + registers an offense and corrects space before first parameter + skips lambda without parens + accepts line break after closing pipe + registers an offense and corrects multiple spaces before parameter + registers an offense and corrects for space with parens + registers an offense and corrects no space after closing pipe + accepts an empty block + registers an offense and corrects all types of spacing issues for a lambda + accepts block parameters with surrounding space that includes line breaks + registers an offense and corrects a lambda for space before first parameter + accepts a block with spaces in the right places + skips lambda without args + accepts a block with parameters but no body + registers an offense and corrects a lambda for space after the last parameter + trailing comma + registers an offense for space after the last comma + registers an offense for space before and after the last comma + when EnforcedStyleInsidePipes is space + registers an offense and corrects no space after last parameter + accepts line break after closing pipe + accepts an empty block + skips lambda without parens + accepts a lambda with spaces in the right places + accepts a block parameter without preceding space + registers an offense and corrects multiple spaces after last parameter + registers an offense and corrects spacing in lambda args + registers an offense and corrects a lambda for extra spacebefore first parameter + registers an offense and corrects a lambda for multiple spacesafter last parameter + skips lambda without args + accepts a block with spaces in the right places + registers an offense for no space before first parameter + registers an offense and corrects extra space before first parameter + registers an offense and corrects space with parens at middle + registers an offense and corrects a lambda for no space before first parameter + accepts a block with parameters but no body + registers an offense and corrects block arguments inside Hash#each + registers an offense and corrects no space after closing pipe + registers an offense and corrects missing space before first argument and after last argument + registers an offense and corrects multiple spaces before parameter + registers an offense and corrects a lambda for no space after last parameter + trailing comma + registers an offense and corrects no space after the last comma + accepts space both before and after the last comma + accepts space after the last comma -RuboCop::Cop::Layout::SpaceBeforeFirstArg - for method calls with parentheses - accepts a method call with space after the left parenthesis - accepts a method call without space - for method calls without parentheses - registers an offense and corrects method call with two spaces before the first arg - accepts a method call with one space before the first arg - registers an offense for method call with no spaces before the first arg - accepts setter call - accepts multiple space containing line break - accepts + operator +RuboCop::Cop::Style::SwapValues + does not register an offense when almost swapping variables + does not register an offense when assigning receiver object at `def` + does not register an offense when idiomatically swapping variables + handles comments when correcting + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping instance variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping class variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping local variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping global variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping mixed variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping constant variables + behaves like verbosely swapping + registers an offense and corrects when verbosely swapping constant with namespaces variables + +RuboCop::Cop::Layout::EmptyLinesAroundArguments + when extra lines + registers and autocorrects offense when empty line between normal arg & block arg + registers and autocorrects offense on correct line for single offense example + registers and autocorrects offense on correct lines for multi-offense example + registers and autocorrects offense when args start on definition line + registers autocorrects empty line whetn args start on definition line + registers and autocorrects offense for empty line after arg + registers and autocorrects offenses when multiple empty lines are detected + registers and autocorrects offense for empty line before arg + registers and autocorrects offense for empty line between args when using safe navigation operator - registers an offense and corrects method call with two spaces before the first arg - when AllowForAlignment is true - accepts method calls with aligned first arguments - when a vertical argument positions are aligned - registers an offense - when AllowForAlignment is false - registers an offense and corrects method calls with aligned first arguments + registers and autocorrects offense for empty line before arg + when no extra lines + accepts one line methods + accepts multiline style argument for method call without selector + accepts block argument with empty line + accepts method with argument that trails off heredoc + accepts method with argument that trails off block + accepts when blank line is inserted between method with arguments and receiver + accepts method with no arguments that trails off block + accepts multiple listed mixed args + accepts listed args starting on definition line + with multiple arguments + ignores empty lines inside of method arguments + with one argument + ignores empty lines inside of method arguments -RuboCop::Cop::Style::IdenticalConditionalBranches - with empty brace - does not raise any error - on if..elsif with no else - doesn't register an offense - on if..else with identical bodies and assigning to a variable used in `if` condition - doesn't register an offense - when one of the case branches is empty - does not register an offense - on if..else with slightly different trailing lines - doesn't register an offense - with a ternary - registers an offense - on case with identical trailing lines - registers and corrects an offense - when using pattern matching - on case-match with identical leading lines - registers and corrects an offense - on case-match without else - doesn't register an offense - when one of the case-match branches is empty +RuboCop::Cop::Style::CommentedKeyword + does not register an offense for certain comments + registers an offense and corrects when commenting on the same line as `def` + registers an offense and corrects when commenting on indented keywords + does not register an offense if AST contains # symbol + registers an offense and corrects when commenting on the same line as `class` + registers an offense and corrects for one-line cases + accepts keyword letter sequences that are not keywords + does not register an offense if there are no comments after keywords + registers an offense and corrects when commenting on the same line as `begin` + registers an offense and corrects when commenting on the same line as `end` + registers an offense and corrects when commenting on the same line as `module` + registers an offense and corrects when commenting after keyword with spaces + checks a long comment in less than one second + +RuboCop::Cop::Lint::Loop + accepts loop/break unless + registers an offense for begin/end/until + registers an offense and corrects for begin/end/while + accepts loop/break if + +RuboCop::Cop::Layout::ExtraSpacing + when AllowForAlignment is false + registers an offense and corrects double extra spacing in variable assignment + registers an offense and corrects alignment with token not preceded by space + ignores whitespace inside a string + accepts aligned values of an implicit hash literal + registers an offense and corrects extra space before a float + registers an offense and corrects extra spacing in class inheritance + ignores trailing whitespace + registers an offense and corrects extra spacing before a unary plus in an argument list + ignores whitespace at the beginning of the line + accepts space between key and value in a hash with hash rockets + with extra spacing for alignment purposes + such as aligning comments on non-adjacent lines + registers offense(s) + such as aligning trailing comments + registers offense(s) + such as lining up different kinds of assignments + registers offense(s) + such as lining up assignments + registers offense(s) + such as aligning tokens with empty line between + registers offense(s) + such as lining up assignments with empty lines and comments in between + registers offense(s) + such as aligning long assignment expressions that include line breaks + registers offense(s) + such as aligning with the same character + registers offense(s) + such as aligning = on lines where there are trailing comments + registers offense(s) + when spaces are present in a single-line hash literal + registers an offense and corrects hashes with hash rockets + registers an offense and corrects hashes with symbol keys + when ForceEqualSignAlignment is true + does not register an offense when optarg equals is not aligned with assignment equals sign + register offenses and correct consecutive operator assignments which are not aligned + does not register alignment errors on outdented lines + register offenses and correct complex nested assignments + does not register an offense if assignments are aligned + does not register an offense if assignments are separated by blanks + registers an offense and corrects consecutive assignments that are not aligned + aligns the first assignment with the following assignment + register offenses and correct consecutive attribute assignments which are not aligned + does not register offenses for multiple complex nested assignments + registers an offense and corrects consecutive aref assignments which are not aligned + when AllowBeforeTrailingComments is + false + does not trigger on only one space before comment + regsiters offense + true + allows it + doesn't interfere with AllowForAlignment + being false + such as lining up assignments with empty lines and comments in between + registers offense(s) + such as aligning = on lines where there are trailing comments + registers offense(s) + such as aligning tokens with empty line between + does not register an offense + such as lining up assignments + registers offense(s) + such as aligning long assignment expressions that include line breaks + registers offense(s) + such as aligning comments on non-adjacent lines + registers offense(s) + such as aligning trailing comments + does not register an offense + such as lining up different kinds of assignments + registers offense(s) + such as aligning with the same character + registers offense(s) + being true + such as lining up different kinds of assignments + allows it + such as aligning with the same character + allows it + such as aligning comments on non-adjacent lines + allows it + such as lining up assignments + allows it + such as aligning tokens with empty line between + allows it + such as aligning trailing comments + allows it + such as aligning = on lines where there are trailing comments + allows it + such as lining up assignments with empty lines and comments in between + allows it + such as aligning long assignment expressions that include line breaks + allows it + when AllowForAlignment is true + accepts space between key and value in a hash with hash rockets + registers an offense and corrects alignment with token not preceded by space + ignores whitespace at the beginning of the line + registers an offense and corrects extra spacing in class inheritance + accepts aligned values of an implicit hash literal + registers an offense and corrects extra space before a float + registers an offense and corrects extra spacing before a unary plus in an argument list + ignores trailing whitespace + registers an offense and corrects double extra spacing in variable assignment + ignores whitespace inside a string + when spaces are present in a single-line hash literal + registers an offense and corrects hashes with symbol keys + registers an offense and corrects hashes with hash rockets + with extra spacing for alignment purposes + such as lining up assignments with empty lines and comments in between + allows it + such as lining up assignments + allows it + such as aligning with the same character + allows it + such as aligning = on lines where there are trailing comments + allows it + such as aligning comments on non-adjacent lines + allows it + such as lining up different kinds of assignments + allows it + such as aligning long assignment expressions that include line breaks + allows it + such as aligning tokens with empty line between + allows it + such as aligning trailing comments + allows it + +RuboCop::Cop::Layout::SpaceInsideStringInterpolation + when EnforcedStyle is space + accepts empty interpolation + for "no_space" style formatted string interpolations + registers offenses and autocorrects + for well-formatted string interpolations + does not register an offense for excess literal spacing + for ill-formatted string interpolations + registers offenses and autocorrects + when EnforcedStyle is no_space + accepts empty interpolation + does not touch spaces inside the interpolated expression + for "space" style formatted string interpolations + registers offenses and autocorrects + when interpolation starts or ends with a line break + ignores comments and whitespace when looking for line breaks does not register an offense - on case-match with identical bodies - registers an offense and corrects - on case..in with identical bodies and assigning to a variable used in `case` condition - doesn't register an offense - on case-match with empty when - doesn't register an offense - on case-match with identical trailing lines - registers and corrects an offense - on case with identical leading lines - registers and corrects an offense - on if..else with identical bodies - registers and corrects an offense - on case without else - doesn't register an offense - on case..when with identical bodies and assigning to a variable used in `case` condition - doesn't register an offense - on if..else with identical leading lines - registers and corrects an offense - on case with identical bodies - registers an offense and corrects - on case with empty when - doesn't register an offense - on if..else with identical trailing lines - registers and corrects an offense + for ill-formatted string interpolations + registers offenses and autocorrects + finds interpolations in string-like contexts + for well-formatted string interpolations + accepts excess literal spacing -RuboCop::Cop::Style::OptionalBooleanParameter - registers an offense when defining class method with optional boolean arg - does not register an offense when defining method with optional non-boolean arg - registers an offense when defining method with multiple optional boolean args - does not register an offense when defining method with keyword boolean arg - does not register an offense when defining method without args - registers an offense when defining method with optional boolean arg - registers an offense when defining method with optional boolean arg that has no space - when AllowedMethods is not empty - does not register an offense +RuboCop::Cop::Metrics::Utils::CodeLengthCalculator + #calculate + raises when unknown foldable type is passed + when class + folds arrays if asked + does not count blank lines + calculates class length + folds heredocs if asked + counts comments if asked + folds hashes if asked + does not count lines of inner classes + when method + folds arrays if asked + folds hashes with comment if asked + counts single line hash with line breaks correctly if asked folding + calculates method length + folds multiline hashes with line break after it as method args if asked + does not count blank lines + counts comments if asked + folds heredocs if asked + counts single line hash as the one of method args if asked folding + counts single line hash with other args correctly if asked folding + folds multiline hashes with line break before it as method args if asked + folds hashes as method args if asked + counts single line hash as the one of method args with safe navigation operator if asked folding + counts single line correctly if asked folding + counts single line without parentheses correctly if asked folding + folds multiline hashes without braces as method args if asked + folds hashes if asked + folds hashes as method kwargs if asked + folds hashes without braces as the one of method args if asked -RuboCop::Formatter::ProgressFormatter - #report_file_as_mark - when no offenses are detected - prints "." - when a refactor severity offense is detected - prints "R" - when a refactor convention offense is detected - prints "C" - when different severity offenses are detected - prints highest level mark - #file_finished - when no offenses are detected - calls #report_as_with_mark - when any offenses are detected - calls #report_as_with_mark - #finished - calls #report_summary - when no offenses are detected - does not report offenses - when any offenses are detected - reports all detected offenses for all failed files +RuboCop::Cop::Lint::RescueType + accepts rescuing nothing + accepts rescuing a single exception + accepts rescuing nothing within a method definition + accepts rescue modifier + behaves like offenses + def rescue + rescuing from {} + registers an offense and autocorrects + begin rescue ensure + rescuing from {} + registers an offense and autocorrects + begin rescue + rescuing from {} before another exception + registers an offense and autocorrects + rescuing from {} + registers an offense and autocorrects + rescuing from {} after another exception + registers an offense and autocorrects + def rescue ensure + rescuing from {} + registers an offense and autocorrects + behaves like offenses + def rescue ensure + rescuing from "#{string}" + registers an offense and autocorrects + def rescue + rescuing from "#{string}" + registers an offense and autocorrects + begin rescue ensure + rescuing from "#{string}" + registers an offense and autocorrects + begin rescue + rescuing from "#{string}" after another exception + registers an offense and autocorrects + rescuing from "#{string}" + registers an offense and autocorrects + rescuing from "#{string}" before another exception + registers an offense and autocorrects + behaves like offenses + begin rescue + rescuing from :symbol before another exception + registers an offense and autocorrects + rescuing from :symbol + registers an offense and autocorrects + rescuing from :symbol after another exception + registers an offense and autocorrects + def rescue ensure + rescuing from :symbol + registers an offense and autocorrects + def rescue + rescuing from :symbol + registers an offense and autocorrects + begin rescue ensure + rescuing from :symbol + registers an offense and autocorrects + behaves like offenses + def rescue + rescuing from [] + registers an offense and autocorrects + begin rescue + rescuing from [] before another exception + registers an offense and autocorrects + rescuing from [] + registers an offense and autocorrects + rescuing from [] after another exception + registers an offense and autocorrects + def rescue ensure + rescuing from [] + registers an offense and autocorrects + begin rescue ensure + rescuing from [] + registers an offense and autocorrects + behaves like offenses + def rescue + rescuing from 0.0 + registers an offense and autocorrects + begin rescue + rescuing from 0.0 + registers an offense and autocorrects + rescuing from 0.0 before another exception + registers an offense and autocorrects + rescuing from 0.0 after another exception + registers an offense and autocorrects + def rescue ensure + rescuing from 0.0 + registers an offense and autocorrects + begin rescue ensure + rescuing from 0.0 + registers an offense and autocorrects + behaves like offenses + def rescue ensure + rescuing from nil + registers an offense and autocorrects + def rescue + rescuing from nil + registers an offense and autocorrects + begin rescue ensure + rescuing from nil + registers an offense and autocorrects + begin rescue + rescuing from nil after another exception + registers an offense and autocorrects + rescuing from nil + registers an offense and autocorrects + rescuing from nil before another exception + registers an offense and autocorrects + behaves like offenses + begin rescue + rescuing from 'string' + registers an offense and autocorrects + rescuing from 'string' after another exception + registers an offense and autocorrects + rescuing from 'string' before another exception + registers an offense and autocorrects + def rescue ensure + rescuing from 'string' + registers an offense and autocorrects + begin rescue ensure + rescuing from 'string' + registers an offense and autocorrects + def rescue + rescuing from 'string' + registers an offense and autocorrects + behaves like offenses + def rescue ensure + rescuing from 0 + registers an offense and autocorrects + begin rescue ensure + rescuing from 0 + registers an offense and autocorrects + def rescue + rescuing from 0 + registers an offense and autocorrects + begin rescue + rescuing from 0 before another exception + registers an offense and autocorrects + rescuing from 0 + registers an offense and autocorrects + rescuing from 0 after another exception + registers an offense and autocorrects -RuboCop::Cop::Lint::RedundantWithObject - registers an offense and corrects when using `ary.each.with_object([]) { |v| v }` - an object is used as a block argument - registers an offense and corrects when using `ary.each_with_object { |v| v }` - registers an offense and corrects when using ary.each_with_object([]) do-end block - registers an offense and corrects when using ary.each_with_object do-end block without parentheses - when missing argument to `each_with_object` - does not register an offense when block has 2 arguments - does not register an offense when block has 1 argument - Ruby 2.7 - registers an offense and corrects when using `ary.each.with_object([]) { _1 }` - registers an offense and corrects when using `ary.each_with_object { _1 }` +RuboCop::Cop::Lint::DuplicateElsifCondition + registers an offense for repeated elsif conditions + registers an offense for subsequent repeated elsif conditions + does not register an offense for partially repeated elsif conditions + registers multiple offenses for multiple repeated elsif conditions + does not register an offense for non-repeated elsif conditions -RuboCop::Cop::Lint::DuplicateMagicComment - does not register an offense when encoding and frozen magic comments are not duplicated - does not register an offense when encoding magic comments are not duplicated - registers an offense when different encoding magic comments are duplicated - does not register an offense when frozen magic comments are not duplicated - registers an offense when frozen magic comments are duplicated - registers an offense when encoding and frozen magic comments are duplicated - registers an offense when same encoding magic comments are duplicated +RuboCop::Cop::Style::Attr + registers offense for attr within class_eval + registers offense for attr within module_eval + accepts attr when it has a receiver + registers an offense attr + accepts attr when it does not take arguments + does not register offense for custom `attr` method + autocorrects + attr with multiple names to attr_reader + attr to attr_reader + attr, false to attr_reader + attr :name, true to attr_accessor :name -RuboCop::Cop::Style::CaseEquality - when AllowOnSelfClass is true - registers an offense and corrects for === when the receiver is self.klass - does not register an offense for === when the receiver is not a camel cased constant - does not register an offense for === when the receiver is self.class - registers an offense and does not correct for === when receiver is of some other type - does not fail when the receiver is implicit - registers an offense and corrects for === when the receiver is a range - registers an offense and corrects for === when the receiver is a regexp - when AllowOnConstant is false - registers an offense and corrects for === when the receiver is a regexp - does not fail when the receiver is implicit - does not register an offense for === when the receiver is not a camel cased constant - registers an offense and corrects for === when the receiver is a range - registers an offense and corrects for === when the receiver is a constant - registers an offense and does not correct for === when receiver is of some other type - when AllowOnConstant is true - does not fail when the receiver is implicit - registers an offense and corrects for === when the receiver is a regexp - registers an offense and does not correct for === when receiver is of some other type - does not register an offense for === when the receiver is not a camel cased constant - does not register an offense for === when the receiver is a constant - registers an offense and corrects for === when the receiver is a range - when AllowOnSelfClass is false - registers an offense and corrects for === when the receiver is self.class - registers an offense and corrects for === when the receiver is a range - registers an offense and corrects for === when the receiver is a regexp - does not fail when the receiver is implicit - does not register an offense for === when the receiver is not a camel cased constant - registers an offense and does not correct for === when receiver is of some other type +RuboCop::Cop::Style::TrailingCommaInArrayLiteral + with single line list of values + when EnforcedStyleForMultiline is comma + accepts literal without trailing comma + accepts empty literal + accepts single element literal without trailing comma + registers an offense for trailing comma + accepts rescue clause + when EnforcedStyleForMultiline is no_comma + accepts single element literal without trailing comma + accepts empty literal + accepts rescue clause + accepts literal without trailing comma + registers an offense for trailing comma + when EnforcedStyleForMultiline is consistent_comma + accepts rescue clause + accepts empty literal + registers an offense for trailing comma + accepts literal without trailing comma + accepts single element literal without trailing comma + with multi-line list of values + when EnforcedStyleForMultiline is no_comma + accepts HEREDOC with commas + accepts a literal with no trailing comma + registers an offense for trailing comma + autocorrects unwanted comma where HEREDOC has commas + when EnforcedStyleForMultiline is comma + registers an offense for a literal with two of the values on the same line and a trailing comma + accepts a multiline word array + accepts literal with two of the values on the same line + accepts a multiline array with a single item and trailing comma + accepts an empty array being passed as a method argument + accepts trailing comma + when closing bracket is on same line as last value + accepts literal with no trailing comma + when EnforcedStyleForMultiline is consistent_comma + accepts a multiline array with a single item and trailing comma + accepts trailing comma + accepts two values on the same line + accepts a multiline array with items on a single line andtrailing comma + registers an offense for literal with two of the values on the same line and no trailing comma + accepts a multiline word array + when closing bracket is on same line as last value + registers an offense for no trailing comma -RuboCop::Cop::Naming::AccessorMethodName - accepts method set_something with kwrestarg - accepts method set_something with kwarg - accepts singleton method set_something with no args - accepts method set_something with no args - registers an offense for method set_something with one arg - accepts method set_something with two args - accepts method set_something with restarg - registers an offense for singleton method get_something with no args - accepts singleton method get_something with args - accepts method set_something with blockarg - accepts method get_something with args - accepts singleton method set_something with two args - registers an offense for method get_something with no args - accepts method set_something with optarg - registers an offense for singleton method set_something with one args - accepts method set_something with kwoptarg - >= Ruby 2.7 - accepts method set_something with arguments forwarding +RuboCop::Cop::Style::NegatedIf + does not blow up for empty if condition + does not blow up for empty unless condition + does not blow up for ternary ops + does not blow up on a negated ternary operator + with “both” style + registers an offense for if with "not" condition + accepts an if where the condition is doubly negated + is not confused by negated elsif + accepts an if/else with negative condition + autocorrects by replacing parenthesized if not with unless + registers an offense for if with exclamation point condition + accepts an if where only part of the condition is negated + with “postfix” style + registers an offense for postfix + does not register an offense for prefix + with “prefix” style + registers an offense for prefix + does not register an offense for postfix -RuboCop::Cop::Lint::SendWithMixinArgument - registers an offense when using `send` with `include` - registers an offense when using `send` with `prepend` - registers an offense when using `__send__` method - does not register an offense when using `include` - does not register an offense when not using a mixin method - registers an offense when using `send` with `extend` - does not register an offense when using `prepend` - does not register an offense when using `extend` - registers an offense when using `public_send` method - when specifying a mixin method as a string - registers an offense when using `send` with `include` - registers an offense when using `send` with `extend` - registers an offense when using `send` with `prepend` - when using namespace for module - registers an offense when using `send` with `include` +RuboCop::Cop::Layout::FirstHashElementIndentation + when hash is right hand side in assignment + accepts correctly indented first pair + accepts single line hash + accepts an empty hash + accepts several pairs per line + accepts a first pair on the same line as the left brace + registers an offense and corrects incorrectly indented first pair + when indentation width is overridden for this cop + registers an offense and corrects incorrectly indented first pair + accepts correctly indented first pair + when the HashAlignment style is separator for : + registers an offense and corrects incorrectly indented } + accepts correctly indented first pair + registers an offense and corrects incorrectly indented first pair with : + when hash is method argument + and argument are not surrounded by parentheses + registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key + accepts indent based on the start of the line where the left brace iswhen the right brace and its following pair is on the same line + registers an offense for incorrectly indented multi-line hash with braces + accepts a correctly indented multi-line hash with braces + accepts single line hash with braces + accepts braceless hash + registers an offense for the first inner hash member not based on the start of line when the outer hash pair has no following siblings + accepts indent based on the left brace when the outer hash key and the left brace is not on the same line + and arguments are surrounded by parentheses + and EnforcedStyle is consistent + registers an offense and corrects incorrect indentation + accepts indent based on the start of the line where the left brace iswhen the right brace and its following pair is on the same line + registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key + accepts normal indentation for first argument + registers an offense for incorrectly indented hash that is the value of a single pair hash + accepts indent based on the left brace when the outer hash key and the left brace is not on the same line + accepts normal indentation for second argument + and EnforcedStyle is special_inside_parentheses + registers an offense and corrects 'consistent' indentation + accepts normal indentation for hash within hash + accepts indent based on the preceding left parenthesiswhen the right brace and its following pair is on the same line + accepts special indentation for first argument + accepts indent based on the left brace when the outer hash key and the left brace is not on the same line + registers an offense and corrects 'align_braces' indentation + registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key + accepts special indentation for second argument + registers an offense for incorrectly indented hash that is the value of a single pair hash + when using safe navigation operator + registers an offense and corrects 'consistent' indentation + when EnforcedStyle is align_braces + accepts single line hash + accepts an empty hash + registers an offense for incorrectly indented hash that is the value of a single pair hash + accepts correctly indented first pair + registers an offense for a hash that is a value of a multi pairs hashwhen the indent of its elements is not based on the hash key + accepts a first pair on the same line as the left brace + accepts several pairs per line + registers an offense and corrects incorrectly indented } + when 'consistent' style is used + registers an offense and corrects incorrect indentation + when 'special_inside_parentheses' style is used + registers an offense and corrects incorrect indentation + when hash is operand + accepts correctly indented first pair + registers an offense and corrects incorrectly indented first pair + registers an offense and corrects incorrectly indented } + when the HashAlignment style is separator for => + registers an offense and corrects incorrectly indented } + accepts correctly indented first pair + registers an offense and corrects incorrectly indented first pair with => + when hash is argument to setter + accepts correctly indented first pair + registers an offense and corrects incorrectly indented first pair -RuboCop::Cop::InternalAffairs::UselessRestrictOnSend - does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` with alias - registers an offense when using `RESTRICT_ON_SEND` and not defines send callback method - does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` with alias_method - does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` with alias - does not register an offense when using `RESTRICT_ON_SEND` and defines `on_send` - does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` with alias_method - does not register an offense when using `RESTRICT_ON_SEND` and defines `after_send` +RuboCop::Cop::Security::JSONLoad + registers an offense and corrects JSON.load + does not register an offense for JSON under another namespace + registers an offense and corrects JSON.restore + allows JSON.parse + allows JSON.dump -RuboCop::Cop::Metrics::ParameterLists - registers an offense for a method def with 5 parameters - does not register an offense when method has allowed amount of optargs - accepts a proc with more than 4 parameters - does not register an offense when method has no args - does not register an offense when method has allowed amount of args with block arg - accepts a method def with 4 parameters - accepts a lambda with more than 4 parameters - registers an offense when optargs count exceeds the maximum - When CountKeywordArgs is false - does not count keyword arguments - does not count keyword arguments without default values - When CountKeywordArgs is true - counts keyword arguments as well +RuboCop::Cop::InternalAffairs::RedundantLetRuboCopConfigNew + registers an offense when using `let(:config)` and `:config` is already specified in `describe` + registers an offense when using `let(:config)` with no argument `RuboCop::Config.new` and `:config` is specified + does not register an offense when using `let(:config)` with arguments to `RuboCop::Config.new` + registers an offense when using `let(:config)` and `:config` is not specified in `describe` -RuboCop::Cop::Style::EvalWithLocation - accepts `eval` with a code that is a variable - registers an offense when using `instance_eval` with improper arguments - accepts `eval` with a string, a filename and `__LINE__` on a new line - registers an offense when using `::Kernel.eval` without any arguments - accepts `eval` with a heredoc, a filename and `__LINE__ + 1` - registers an offense when using `eval` with improper arguments - accepts `eval` with a string, a filename and `__LINE__` - registers an offense when using `#instance_eval` without any arguments - registers an offense when using `#eval` without lineno - does not register an offense if `eval` is called on another object - registers an offense when using `#module_eval` without any arguments - registers an offense when using `module_eval` with improper arguments - registers an offense when using `Kernel.eval` without any arguments - does not register an offense when using eval with block argument - registers an offense when using `#eval` with a heredoc and an incorrect line number - registers an offense when using `#eval` with a string on a new line - registers an offense when using `#eval` with an incorrect line number - registers an offense when using correct file argument but incorrect line - registers an offense when using `#instance_eval` with a string argument in parentheses - registers an offense when using `#class_eval` without any arguments - registers an offense when using `#eval` without any arguments - registers an offense when using `class_eval` with improper arguments - registers an offense when using `#eval` with `binding` only - registers an offense when using `#class_eval` with an incorrect lineno +RuboCop::Cop::Naming::HeredocDelimiterNaming + with a non-interpolated heredoc + when using single quoted delimiters + registers an offense with a non-meaningful delimiter + does not register an offense with a meaningful delimiter + when using non-word delimiters + registers an offense + when using back tick delimiters + does not register an offense with a meaningful delimiter + registers an offense with a non-meaningful delimiter + when using double quoted delimiters + does not register an offense with a meaningful delimiter + registers an offense with a non-meaningful delimiter + with a naked heredoc + does not register an offense with a meaningful delimiter + registers an offense with a non-meaningful delimiter + with an interpolated heredoc + registers an offense with a non-meaningful delimiter + does not register an offense with a meaningful delimiter + with multiple heredocs starting on the same line + registers an offense with a trailing non-meaningful delimiter + does not register an offense with meaningful delimiters + registers an offense with a leading non-meaningful delimiter + with a squiggly heredoc + registers an offense with a non-meaningful delimiter + does not register an offense with a meaningful delimiter + when the delimiter contains non-letter characters + does not register an offense when delimiter contains an underscore + does not register an offense when delimiter contains a number -RuboCop::Cop::Style::DoubleNegation - when `EnforcedStyle: forbidden` - registers an offense for `!!` when return location and using `rescue` and `ensure` - does not register an offense for ! - registers an offense and corrects for `!!` when using `return` keyword - registers an offense and corrects for `!!` - registers an offense for `!!` when return location and using `ensure` - registers an offense and corrects for `!!` when return location - does not register an offense for `not not` - registers an offense and corrects for `!!` when not a return location - registers an offense for `!!` when return location and using `rescue`, `else`, and `ensure` - registers an offense for `!!` when return location and using `rescue` - when `EnforcedStyle: allowed_in_returns` - registers an offense and corrects for `!!` with nested array at return location - does not register an offense for `!!` when return location by `define_singleton_method` - does not register an offense for `!!` when return location and using `rescue`, `else`, and `ensure` - does not register an offense for `!!` with array when return location and using `if`, `elsif`, and `else` - registers an offense and corrects for `!!` - registers an offense and corrects for `!!` with complex array at return location - does not register an offense for `!!` when return location and using `unless` - does not register an offense for `!!` when return location and using `rescue` and `ensure` - does not register an offense for `!!` when return location by `define_method` - registers an offense and corrects for `!!` with array when not return locationand using `if`, `elsif`, and `else` - registers an offense and corrects for `!!` with hash when not return locationand using `case`, `when`, and `else` - does not register an offense for `!!` with hash when return location and using `if`, `elsif`, and `else` - does not register an offense for ! - does not register an offense for `!!` when return location and using `rescue` - registers an offense and corrects for `!!` with multi-line array at return location - does not register an offense for `not not` - registers an offense and corrects for `!!` when not return locationand using `if`, `elsif`, and `else` - registers an offense and corrects for `!!` with single-line array at return location - registers an offense and corrects for `!!` when not return locationand using `case`, `when`, and `else` - registers an offense and corrects for `!!` with hash when not return locationand using `if`, `elsif`, and `else` - does not register an offense for `!!` when using `return` keyword - registers an offense and corrects for `!!` with multi-line hash at return location - does not register an offense for `!!` with array when return location and using `case`, `when`, and `else` - registers an offense and corrects for `!!` when not a return location - registers an offense and corrects for `!!` with nested hash at return location - does not register an offense for `!!` when return location and using `if`, `elsif`, and `else` - does not register an offense for `!!` when return location and using `case`, `when`, and `else` - registers an offense and corrects for `!!` with single-line hash at return location - registers an offense and corrects for `!!` with array when not return locationand using `case`, `when`, and `else` - does not register an offense for `!!` when return location - does not register an offense for `!!` with hash when return location and using `case`, `when`, and `else` - does not register an offense for `!!` when return location and using `ensure` - registers an offense and corrects for `!!` when not return location and using `unless` - Ruby >= 2.7 - does not register an offense for `!!` when return location and using `case`, `in`, and `else` - Ruby >= 2.7 - registers an offense and corrects for `!!` when not return locationand using `case`, `in`, and `else` +RuboCop::Cop::Style::GlobalVars + does not register an offense for built-in variable $-I + does not register an offense for built-in variable $~ + does not register an offense for built-in variable $! + does not register an offense for built-in variable $-p + does not register an offense for built-in variable $CHILD_STATUS + does not register an offense for built-in variable $-i + does not register an offense for built-in variable $DEFAULT_OUTPUT + does not register an offense for built-in variable $NR + does not register an offense for built-in variable $FS + does not register an offense for built-in variable $< + does not register an offense for built-in variable $' + does not register an offense for built-in variable $VERBOSE + does not register an offense for built-in variable $LOADED_FEATURES + does not register an offense for built-in variable $/ + does not register an offense for built-in variable $stdin + does not register an offense for built-in variable $PROGRAM_NAME + does not register an offense for built-in variable $-d + does not register an offense for built-in variable $OFS + does not register an offense for built-in variable $> + does not register an offense for built-in variable $INPUT_LINE_NUMBER + does not register an offense for built-in variable $-v + does not register an offense for built-in variable $LAST_MATCH_INFO + does not register an offense for built-in variable $= + does not register an offense for built-in variable $DEBUG + does not register an offense for built-in variable $stderr + does not register an offense for built-in variable $. + does not register an offense for built-in variable $ERROR_INFO + does not register an offense for built-in variable $@ + does not register an offense for built-in variable $LAST_READ_LINE + does not register an offense for built-in variable $-w + does not register an offense for built-in variable $? + does not register an offense for built-in variable $_ + does not register an offense for built-in variable $ORS + does not register an offense for built-in variable $: + does not register an offense for built-in variable $0 + does not register an offense for built-in variable $$ + does not register an offense for built-in variable $-l + does not register an offense for built-in variable $SAFE + does not register an offense for built-in variable $* + does not register an offense for built-in variable $\ + does not register an offense for built-in variable $LAST_PAREN_MATCH + does not register an offense for built-in variable $INPUT_RECORD_SEPARATOR + does not register an offense for built-in variable $LOAD_PATH + does not register an offense for built-in variable $PID + does not register an offense for built-in variable $& + does not register an offense for built-in variable $FILENAME + does not register an offense for built-in variable $; + does not register an offense for built-in variable $OUTPUT_RECORD_SEPARATOR + does not register an offense for built-in variable $IGNORECASE + does not register an offense for built-in variable $" + does not register an offense for built-in variable $-0 + does not register an offense for built-in variable $ARGV + does not register an offense for built-in variable $MATCH + does not register an offense for built-in variable $FIELD_SEPARATOR + does not register an offense for built-in variable $ERROR_POSITION + does not register an offense for backrefs like $1 + does not register an offense for built-in variable $-a + allows user permitted variables + does not register an offense for built-in variable $RS + does not register an offense for built-in variable $PREMATCH + does not register an offense for built-in variable $ENV_JAVA + does not register an offense for built-in variable $stdout + does not register an offense for built-in variable $+ + does not register an offense for built-in variable $POSTMATCH + does not register an offense for built-in variable $DEFAULT_INPUT + does not register an offense for built-in variable $, + registers an offense for $custom + does not register an offense for built-in variable $JRUBY_REVISION + does not register an offense for built-in variable $` + does not register an offense for built-in variable $OUTPUT_FIELD_SEPARATOR + does not register an offense for built-in variable $JRUBY_VERSION + does not register an offense for built-in variable $-F + does not register an offense for built-in variable $PROCESS_ID + does not register an offense for built-in variable $CLASSPATH -RuboCop::Cop::Layout::SingleLineBlockChain - registers an offense for no selector method call chained on the same line as a block - does not register an offense for method call chained on a new line after a single line block with trailing dot - does not register an offense for method call chained without a dot - registers an offense for method call chained on the same line as a block - does not register an offense for method call chained on the same line as a multiline block - does not register an offense for method call chained on a new line after a single line block +RuboCop::Cop::Lint::RedundantCopDisableDirective + .check + when there are disabled lines + and there are no offenses + and a comment disables + itself and all cops + disabled on different ranges + returns no offense + misspelled cops + returns an offense + all cops + returns an offense + a cop that is disabled in the config + returns an offense + when that cop was previously enabled + returns no offense + if that cop has offenses + returns an offense + multiple cops, and the leftmost one has no offenses + returns an offense + when using a directive comment after a non-directive comment + returns an offense + multiple cops, with abbreviated names + one of them has offenses + returns an offense + itself and another cop + and the other cop is disabled a second time + returns no offense + disabled on the same range + returns no offense + disabled on different ranges + returns no offense + multiple cops + returns an offense + multiple cops, and one of them has offenses + returns an offense + comment is not at the beginning of the file + and not all cops have offenses + returns an offense + an unknown cop + returns an offense + one cop + returns an offense + and there is an offense + and a comment disables + that cop + returns no offense + all cops + returns no offense + that cop but on other lines + returns an offense + and there are two offenses + and a comment disables + one cop twice + returns an offense + one cop and then all cops + returns an offense + when there are no disabled lines + returns no offense + with a disabled department + does not remove correct department + removes redundant department + removes entire comment + removes cop duplicated by department and leaves free text as a comment + removes cop duplicated by department on previous line + removes cop duplicated by department + autocorrecting whitespace + inline comment + removes the comment and preceding whitespace + when the comment is not the first line of the file + preserves whitespace before the comment + nested inside a namespace + preserves indentation + when there is only whitespace before the comment + leaves the whitespace + when the comment is the first line of the file + followed by a newline + removes the comment and newline + followed by code + removes the comment + followed by another comment + removes the comment and newline + when there is a blank line before inline comment + removes the comment and preceding whitespace -RuboCop::Cop::Layout::EmptyLineAfterMagicComment - registers an offense when code that immediately follows typed comment - accepts magic comment with shareable_constant_value - accepts magic comment with typed - registers an offense for documentation immediately following comment - accepts code that separates the comment from the code with a newline - registers offense when frozen_string_literal used with shareable_constant_value without empty line - registers an offense for code that immediately follows comment - accepts a source file with only a magic comment - accepts magic comment followed by encoding - registers an offense when multiple magic comments without empty line - accepts an empty source file +RuboCop::Cop::Style::For + when for is the enforced style + registers an offense for multiline each + registers multiple offenses + accepts for + registers an offense for each without an item and uses _ as the item + registers an offense for a tuple of items + registers an offense for correct + opposite style + accepts single line each + when using safe navigation operator + does not break + Ruby 2.7 + registers an offense for each without an item and uses _ as the item + when each is the enforced style + accepts multiline each + accepts :for + registers multiple offenses + accepts def for + registers an offense for opposite + correct style + registers an offense for for + autocorrect + corrects an array with `|` operator + corrects an array with `||` operator + corrects a tuple of items + corrects an array with `&` operator + corrects an array with `*` operator + changes for that does not have do or semicolon to each + corrects an array with `&&` operator + corrects an array with `+` operator + corrects to `each` without parenthesize collection if non-operator method called + corrects an array with `-` operator + with range + changes for to each + changes for that does not have do or semicolon to each + without parentheses + changes for to each + changes for that does not have do or semicolon to each -RuboCop::Cop::Lint::EnsureReturn - does not check when ensure block has no body - does not register an offense for return outside ensure - registers an offense when returning multiple values in `ensure` - registers an offense and corrects for return with argument in ensure - registers an offense and corrects for return in ensure +RuboCop::Formatter::DisabledConfigFormatter + when no files are inspected + creates a .rubocop_todo.yml even in such case + when exclude_limit option is omitted + disables the cop with 15 offending files + when any offenses are detected + displays YAML configuration disabling all cops with offenses + when there's .rubocop.yml + merges in excludes from .rubocop.yml + when exclude_limit option is passed + respects the file exclusion list limit + with autocorrect supported cop + adds a comment about --autocorrect option -RuboCop::FileFinder - #find_last_file_upwards - returns nil when file is not found - returns the last file found upwards - #find_file_upwards - returns a file to be found upwards - returns nil when file is not found +RuboCop::Cop::Style::UnpackFirst + ruby version >= 2.4 + does not register offense + when using `#unpack1` + when using `#unpack` accessing second element + registers offense + when using `#unpack` with dot and square brackets + when using `#unpack` with `#slice` + when using `#unpack` with `#first` + when using `#unpack` with square brackets + when using `#unpack` with `#at` -RuboCop::Cop::Lint::CircularArgumentReference - circular argument references in keyword arguments - when there are multiple offensive keyword arguments - registers an offense - when the keyword argument is not circular, but calls a method of some other object with the same name - does not register an offense - when there is one circular argument reference - registers an offense - when the keyword argument is not circular - does not register an offense - when the keyword argument is not circular, but calls a method of its own class with a self specification - does not register an offense - when the keyword argument is not circular, and calls a method - does not register an offense - circular argument references in ordinal arguments - when the method does not contain a circular argument reference - does not register an offense - when the method contains a circular argument reference - registers an offense - when the seemingly-circular default value is a method call - does not register an offense +RuboCop::Cop::InternalAffairs::ExampleDescription + with `expect_offense` + does not register an offense when given an unexpected description + does not register an offense when given a proper description + registers an offense when given an improper description + with `expect_no_corrections` + registers an offense when given an improper description + in conjunction with expect_offense + registers an offense when given an improper description + when not making an expectation on offenses + does not register an offense + with `expect_correction` + registers an offense when given an improper description + in conjunction with expect_offense + registers an offense when given an improper description + when the description is invalid for both methods + registers an offense for the first method encountered + with `expect_no_offenses` + does not register an offense when given an unexpected description + registers an offense when given an improper description + does not register an offense when given a proper description + does not crash when given a proper description that is split with + -RuboCop::Cop::Style::ColonMethodDefinition - accepts a class method defined using . - using the class name - registers an offense for a class method defined using :: - using self - registers an offense for a class method defined using :: +RuboCop::Cop::Style::ClassMethodsDefinitions + when EnforcedStyle is def_self + registers and corrects an offense when defining class methods with `class << self` with comment only body + does not register an offense when defining class methods with `def self.method` + correctly handles def self.x within class << self + removes empty class << self when correcting + registers an offense and corrects when defining class methods with `class << self` and there is no blank line between method definition and attribute accessor + does not register an offense when defining singleton methods using `self << object` + registers an offense and corrects when defining class methods with `class << self` + correctly handles class << self containing multiple methods + does not register an offense when class << self contains only class methods + does not register an offense when class << self does not contain methods + registers and corrects an offense when defining class methods with `class << self` with inline comment + does not register an offense when `class << self` contains non public methods + correctly handles methods with annotation comments + when EnforcedStyle is self_class + registers an offense when defining class methods with `def self.method` + does not register an offense when defining singleton methods not on self + does not register an offense when defining class methods with `class << self` -RuboCop::Cop::Layout::SpaceInsideRangeLiteral - registers an offense in multiline range literal with space in it - accepts no space inside .. literal - registers an offense for space inside ... literal - registers an offense for space inside .. literal - accepts multiline range literal with no space in it - accepts complex range literal with space in it - accepts no space inside ... literal +RuboCop::Formatter::Colorizable + #black + invokes #colorize(string, black + #green + invokes #colorize(string, green + #magenta + invokes #colorize(string, magenta + #white + invokes #colorize(string, white + #colorize + when the global Rainbow.enabled is false + and the formatter's output is not a tty + does nothing + and the formatter's output is a tty + does nothing + when the global Rainbow.enabled is true + and output is not a tty, but --color option was provided + colorizes the passed string + and the formatter's output is a tty + colorizes the passed string + and the formatter's output is not a tty + does nothing + #cyan + invokes #colorize(string, cyan + #yellow + invokes #colorize(string, yellow + #red + invokes #colorize(string, red + #blue + invokes #colorize(string, blue -RuboCop::Cop::Layout::SpaceBeforeComment - registers an offense and corrects missing space before an EOL comment - accepts an EOL comment with a preceding space - registers an offense and corrects after a heredoc - accepts a comment that begins a line - accepts a doc comment +RuboCop::Cop::Lint::IneffectiveAccessModifier + when `protected` is applied to a class method + registers an offense + when there is `begin` before a method definition + does not register an offense + when no access modifier is used + doesn't register an offense + when `private` is applied to a class method + registers an offense + when a `class << self` block is used + doesn't register an offense + when there is an intervening instance method + still registers an offense + when `private_class_method` is used + when `private_class_method` does not contain the method + registers an offense + when `private_class_method` contains all private method names + doesn't register an offense -RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective - registers an offense for disabling all cops - registers an offense for disabled cop within source code - registers an offense for enabled cop within source code - with AllowedCops - when an allowed cop is disabled - does not register an offense - when using leading source comment - does not register an offense - when an mix of cops are disabled - registers an offense and corrects - when an non-allowed cop is disabled - registers an offense and corrects +RuboCop::Cop::Utils::FormatString + finds the correct number of fields + #named_interpolation? + behaves like named format sequence + does not detect escaped named format sequence + detects named format sequence + behaves like named format sequence + detects named format sequence + does not detect escaped named format sequence + behaves like named format sequence + does not detect escaped named format sequence + detects named format sequence + behaves like named format sequence + does not detect escaped named format sequence + detects named format sequence + #valid? + returns false when there are numbered and named formats + returns true when there are only named with escaped `%` formats + returns true when there are only named formats + returns true when there are only unnumbered formats + returns true when there are only numbered formats + returns false when there are unnumbered and named formats + returns false when there are unnumbered and numbered formats -RuboCop::Cop::Style::VariableInterpolation - registers an offense for interpolated global variables in backticks - registers an offense for interpolated instance variables - registers an offense for interpolated class variables - registers an offense for interpolated regexp back references - does not register an offense for variables in expressions - registers an offense for interpolated global variables in symbol - registers an offense for interpolated regexp nth back references - registers an offense for interpolated global variables in string - registers an offense for interpolated global variables in regexp +RuboCop::Cop::Style::BisectedAttrAccessor + registers an offense for accessors with the same visibility in different scopes + registers an offense and corrects when both accessors of the name exists + registers an offense and corrects when both accessors of the name exists and accessor contains multiple names + registers an offense and corrects when attr and attr_writer exists + does not register an offense when only one accessor of the name exists + registers an offense and corrects properly when attr_writer is before attr_reader + registers an offense and corrects when within eigenclass + registers an offense and corrects when both accessors are in the same visibility scope + does not register an offense when using `attr_accessor` + registers an offense and corrects when both accessors of the splat exists + does not register an offense when accessors are within different visibility scopes + registers and corrects in a module + multiple bisected accessors + when all attr names are bisected + registers and replaces with attr_accessor + when some attr names are bisected + registers and retains non-bisected attrs -RuboCop::Cop::Lint::Debugger - does not register an offense for a irb in comments - does not register an offense for a remote_pry in comments - does not register an offense for a irb method - does not register an offense for a save_and_open_page method - does not register an offense for a debugger in comments - does not register an offense for a pry_remote method - does not register an offense for a save_and_open_screenshot in comments - does not register an offense for a pry in comments - does not register an offense for a pry method - does not register an offense for a byebug method - does not register an offense for a pry_remote in comments - does not register an offense for a console method - does not register an offense for a save_and_open_page in comments - does not register an offense for a binding method that is not disallowed - does not register an offense for a remote_pry method - does not register an offense for a remote_byebug method - does not register an offense for a byebug in comments - does not register an offense for a remote_byebug in comments - does not register an offense for a debugger method - does not register an offense for a save_and_open_screenshot method - does not register an offense for a console in comments - web console - registers an offense for a `binding.console` call - does not register an offense for `console` without a receiver - RubyJard - registers an offense for a jard call - when a method group is disabled with nil - does not register an offense for a Pry debugger call - does register an offense for another group - byebug - registers an offense for a Kernel.byebug call - registers an offense for a remote_byebug call - registers an offense for a byebug with an argument call - registers an offense for a byebug call - registers an offense for a Kernel.remote_byebug call - with the DebuggerMethods configuration - registers an offense for a `custom_debugger` call - does not register an offense for a byebug call - with a const chain and a method chain - registers an offense for a `Foo::Bar::Baz.debug.this.code` call - with a method chain - registers an offense for a `debugger.foo.bar` call - nested custom configurations - registers an offense for a `custom_debugger call - with a const chain - registers an offense for a `Foo::Bar::Baz.debug` call - pry - registers an offense for a Pry.rescue call - registers an offense for a remote_pry binding with an argument call - registers an offense for a pry binding with an argument call - does not register an offense for a `pry` call without binding - registers an offense for a pry_remote binding with an argument call - does not register an offense for a `rescue` call without Pry - registers an offense for a pry binding call - registers an offense for a binding.pry with Kernel call - registers an offense for a pry_remote binding call - registers an offense for a remote_pry binding call - built-in methods - registers an offense for a binding.irb with Kernel call - registers an offense for a irb binding call - debug.rb - registers an offense for a `b` binding call - registers an offense for a `break` binding call - registers an offense for a `binding.b` with `Kernel` call - registers an offense for a `binding.break` with `Kernel` call - rails - registers an offense for a debugger with ::Kernel call - registers an offense for a debugger call - registers an offense for a debugger with an argument call - registers an offense for a debugger with Kernel call - capybara - registers an offense for save_and_open_page - registers an offense for save_and_open_screenshot - with an argument - registers an offense for save_and_open_page - registers an offense for save_and_open_screenshot - when a method group is disabled with false - does register an offense for another group - does not register an offense for a Pry debugger call +RuboCop::Cop::Lint::DeprecatedOpenSSLConstant + does not register an offense with cipher constant and send argument is a method + registers an offense with AES + blocksize constant and corrects + does not register an offense with cipher constant and argument is a constant + registers an offense with cipher constant and two arguments and corrects + does not register an offense when building digest using an algorithm string and nested digest constants + registers an offense with cipher constant and no arguments and corrects + does not register an offense when using cipher with a string + registers an offense with cipher constant and no arguments and corrects + does not register an offense with cipher constant and argument is a variable + registers an offense with cipher constant and no arguments and corrects + registers an offense with cipher constant and `cbc` argument and corrects + registers an offense when using ::Digest class methods on an algorithm constant and corrects + registers an offense when building an instance using an digest constant and corrects + registers an offense when using an digest constant with chained methods and corrects + does not register an offense when using ::Digest class methods with an algorithm string and value + does not register an offense when building digest using an algorithm string + registers an offense with cipher constant and double quoted string argument and corrects + registers an offense with cipher constant and one argument and corrects + registers an offense with AES + blocksize constant and mode argument and corrects + registers an offense with cipher constant and no arguments and corrects + when used in a block + registers an offense when using ::Digest class methods on an algorithm constant and corrects -RuboCop::Cop::Style::RaiseArgs - when enforced style is compact - accepts a raise with msg argument - accepts a raise with an exception argument - accepts exception constructor with keyword arguments and message argument - with a raise with 3 args - reports an offense - with correct + opposite - reports multiple offenses - reports an offense - with a raise with exception instantiation and message arguments - reports an offense - with a raise with 2 args and exception object is assigned to a local variable - reports an offense - with a raise with 2 args - reports an offense - when used in a logical or expression - registers an offense and autocorrects - when used in a ternary expression - registers an offense and autocorrects - when used in a logical and expression - registers an offense and autocorrects - when enforced style is exploded - accepts exception constructor with more than 1 argument - accepts a raise with 3 args - accepts a raise with `new` method without receiver - accepts exception constructor with keyword arguments - accepts a raise with splatted arguments - accepts a raise with msg argument - ignores a raise with an exception argument - accepts a raise when exception object is assigned to a local variable - accepts a raise with 2 args - with opposite + correct - reports multiple offenses - reports an offense for opposite + correct - with a raise with exception object - when used in a logical or expression - registers an offense and autocorrects - with one argument - reports an offense - when used in a ternary expression - registers an offense and autocorrects - with no arguments - reports an offense - when used in a logical and expression - registers an offense and autocorrects - when an exception object is assigned to a local variable - autocorrects to exploded style - when exception type is in AllowedCompactTypes - accepts exception constructor with no arguments - with more than one argument - accepts exception constructor - with one argument - accepts exception constructor +RuboCop::Cop::Style::LineEndConcatenation + autocorrects a + with \ to just \ + registers an offense for dynamic string concat at line end + registers an offense for string concat with << and \ at line ends + autocorrects only the lines that should be autocorrected + registers multiple offenses when there are chained concatenations + accepts string concat with a return value of method on a string + registers an offense for string concat with << at line end + registers an offense for string concat at line end + accepts string concat with a return value of method on an interpolated string + registers multiple offenses when there are chained concatenationscombined with << calls + accepts string concat at line end when % literals are involved + accepts string concat at line end for special strings like __FILE__ + accepts string concat at line end when followed by comment + registers multiple offenses when there are chained << methods + registers offenses only for the appropriate lines in chained concats + registers an offense for dynamic string concat with << at line end + accepts string concat on the same line + autocorrects a + with trailing whitespace to \ + accepts string concat at line end when followed by a comment line -RuboCop::Cop::Migration::DepartmentName - when a disable comment contains a plain comment - accepts - when a disable comment has cop names with departments +RuboCop::Cop::Style::RedundantInterpolation + registers an offense for "#{1 + 1; 2 + 2}" + registers an offense for "#{$+}" + registers an offense for "%|#{1 + 1}|" + registers an offense for "#{1 + 1}" + registers an offense for "#$1" + accepts strings with characters before the interpolation + registers an offense for "#{do_something(42)}" + registers an offense for "#{@@var}" + accepts strings that are part of a %W() + accepts strings implicitly concatenated with a later string + accepts strings with characters after the interpolation + registers an offense for "#$+" + registers an offense for "%Q(#{1 + 1})" + registers an offense for "#{foo.do_something 42}" + registers an offense for "#$var" + registers an offense for "#{$var}" + registers an offense for "#@var" + registers an offense for "#{do_something 42}" + registers an offense for "#{$1}" + registers an offense for "#{var}" + registers an offense for "#{number}" + accepts strings implicitly concatenated with an earlier string + registers an offense for ["#{@var}"] + registers an offense for "#{@var}" + registers an offense for "#@@var" + +RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor + constructor does not have disjunctive assignment accepts - when a disable comment contains an unexpected character for department name + empty constructor accepts - when only department name has given - does not register an offense - when todo/enable comments have cop names without departments - registers offenses and corrects - registers offenses and corrects when there is space around `:` - registers offenses and corrects when using a legacy cop name - when an unexpected disable comment format - does not register an offense + constructor has disjunctive assignment + LHS is ivar + registers an offense and corrects + constructor calls any method before disjunctive assignment + accepts + constructor calls super after assignment + registers an offense and corrects + constructor calls super before disjunctive assignment + accepts + LHS is lvar + accepts -RuboCop::Cop::Layout::TrailingEmptyLines - when EnforcedStyle is final_blank_line - autocorrects missing blank line - registers an offense for multiple blank lines in an empty file - autocorrects missing newline - accepts final blank line - registers an offense for final newline - registers an offense for no final newline - registers an offense for multiple trailing blank lines - when EnforcedStyle is final_newline - accepts final blank lines if they come after __END__ - registers an offense for no final newline after block comment - registers an offense for multiple trailing blank lines - accepts final newline - accepts an empty file - autocorrects even if some lines have space - accepts final blank lines if they come after __END__ in empty file - registers an offense for no final newline after assignment - registers an offense for multiple blank lines in an empty file +RuboCop::Cop::Style::SymbolLiteral + accepts string syntax when symbols have special chars in them + registers an offense for word-line symbols using string syntax + accepts string syntax when symbol start with a digit + accepts string syntax when symbols have whitespaces in them -RuboCop::Cop::Layout::EmptyLinesAroundBlockBody - when EnforcedStyle is no_empty_lines for do end block - registers an offense for block body starting with a blank passed to a multi-line method call - accepts block body starting with a line with spaces - registers an offense for block body starting with a blank - is not fooled by single line blocks - registers an offense for block body ending with a blank - Ruby 2.7 - registers an offense for block body ending with a blank - when EnforcedStyle is empty_lines for { } block - registers an offense for block body not starting or ending with a blank - is not fooled by single line blocks - ignores block with an empty body - when EnforcedStyle is no_empty_lines for { } block - registers an offense for block body starting with a blank passed to a multi-line method call - accepts block body starting with a line with spaces - registers an offense for block body ending with a blank - registers an offense for block body starting with a blank - is not fooled by single line blocks - Ruby 2.7 - registers an offense for block body ending with a blank - when EnforcedStyle is empty_lines for do end block - registers an offense for block body not starting or ending with a blank - is not fooled by single line blocks - ignores block with an empty body +RuboCop::Cop::Lint::ToJSON + does not register an offense when using `#to_json` with arguments + registers an offense and corrects using `#to_json` without arguments -RuboCop::Cop::Layout::MultilineMethodCallBraceLayout - ignores single-line calls - ignores calls with a multiline empty brace - ignores calls with an empty brace - ignores implicit calls - ignores calls without arguments - when EnforcedStyle is new_line - ignores single-line calls with multi-line receiver with leading dot - still ignores single-line calls - ignores single-line calls with multi-line receiver - behaves like multiline literal brace layout trailing comma - symmetrical style - opening brace on same line as first element - last element has a trailing comma - autocorrects closing brace on different line from last element - same_line style - opening brace on same line as first element - last element has a trailing comma - autocorrects closing brace on different line as last element - behaves like multiline literal brace layout - new_line style - opening brace on same line as first element - allows closing brace on different line from multi-line element - autocorrects closing brace on same line as last element - detects closing brace on same line as last multiline element - allows closing brace on different line from last element - opening brace on separate line from first element - allows closing brace on separate line from last multiline element - allows closing brace on separate line from last element - detects closing brace on same line as last element - same_line style - opening brace on same line as first element - allows closing brace on same line from last element - detects closing brace on different line from multiline element - autocorrects closing brace on different line as last element - allows closing brace on same line as multi-line element - with a chained call on the closing brace - but no comment after the last element - autocorrects the closing brace - and a comment after the last element - detects closing brace on separate line from last elementbut does not autocorrect the closing brace - opening brace on separate line from first element - detects closing brace on different line from last element - allows closing brace on same line as last element - allows closing brace on same line as last multiline element - heredoc - detects heredoc structures that are safe to add to - ignores heredocs that could share a last line - symmetrical style - opening brace on separate line from first element - detects closing brace on same line as last element - allows closing brace on separate line from last multiline element - allows closing brace on separate line from last element - opening brace on same line as first element - detects closing brace on different line from last element - autocorrects closing brace on different line from last element - allows closing brace on same line as last element - allows closing brace on same line as last multiline element - with a chained call on the closing brace - and a comment after the last element - detects closing brace on separate line from last elementbut does not autocorrect the closing brace - but no comment after the last element - autocorrects the closing brace - when comment present before closing brace - corrects closing brace without crashing +RuboCop::Cop::Lint::ConstantResolution + registers no offense when qualifying a const + registers no offense qualifying a namespace const + registers an offense not qualifying a const + registers an offense not qualifying a namespace const + with Ignore set + registers an with a namespace const + registers no offense when an unqualified namespace const + registers no offense when qualifying a const + registers no offense with an unqualified const + registers an offense not qualifying another const + registers no offense qualifying a namespace const + module & class definitions + does not register offense + with Only set + registers no with a namespace const + registers no offense when qualifying a const + registers an offense when an unqualified namespace const + registers no offense qualifying a namespace const + registers an offense with an unqualified const + registers no offense not qualifying another const -RuboCop::Cop::Lint::AmbiguousOperatorPrecedence - does not register an offense when there is only one operator in the expression - does not register an offense when expressions are wrapped in parentheses by precedence - does not register an offense when boolean expressions are wrapped in parens - registers an offense when the entire expression is wrapped in parentheses - corrects a super long expression in reverse precedence order - allows an operator with `or` - allows an operator with `and` - registers an offense when an expression with mixed precedence has no parens - does not register an offense when all operators in the expression have the same precedence - corrects a super long expression in precedence order - registers an offense when an expression with mixed boolean operators has no parens - does not register an offense when expressions are wrapped in parentheses by reverse precedence - registers an offense for expressions containing booleans and operators +RuboCop::Cop::Style::OptionalBooleanParameter + registers an offense when defining method with multiple optional boolean args + registers an offense when defining class method with optional boolean arg + registers an offense when defining method with optional boolean arg that has no space + does not register an offense when defining method with keyword boolean arg + does not register an offense when defining method without args + does not register an offense when defining method with optional non-boolean arg + registers an offense when defining method with optional boolean arg + when AllowedMethods is not empty + does not register an offense -RuboCop::Cop::Style::EmptyLiteral - Empty Array - does not register an offense for Array.new(3) - autocorrects Array.new in block in block - registers an offense for ::Array.new - registers an offense for Array.new() - registers an offense for Array.new - does not register an offense for ::Array.new with block - does not register an offense Array.new with block - does not register Array.new with block in other block - Empty String - registers an offense for ::String.new - does not register an offense for ::String.new("top") - registers an offense for String.new - does not register an offense for String.new("top") - registers an offense for String.new() - when Style/FrozenStringLiteral is enabled - and there is a frozen_string_literal: false comment - registers an offense and corrects - and there is no magic comment - does not register an offense - when double-quoted string literals are preferred - registers an offense for String.new - registers an offense for ::String.new - when frozen string literals is enabled - does not register an offense for String.new - Empty Hash - autocorrects Hash.new to {} and wraps it in parentheses when it is the only argument to super - does not register an offense for ::Hash.new { block } - autocorrects Hash.new to {} as the first parameter to a method - autocorrects Hash.new to {} and wraps all arguments in parentheses when it is the first argument to super - registers an offense for Hash.new - does not register an offense for Hash.new(3) - does not register an offense for ::Hash.new(3) - registers an offense for Hash.new() - registers an offense for ::Hash.new - autocorrects Hash.new in block - does not register an offense for Hash.new { block } - autocorrects Hash.new to {} as the only parameter to a method - autocorrects Hash.new to {} in various contexts - Ruby 2.7 - does not register an offense for ::Hash.new { _1[_2] = [] } - does not register an offense for Hash.new { _1[_2] = [] } +RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout + ignores single-line defs + ignores implicit defs + ignores defs without params + heredoc + detects heredoc structures that are safe to add to + ignores heredocs that could share a last line + new_line style + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last element + allows closing brace on separate line from last multiline element + opening brace on same line as first element + allows closing brace on different line from last element + allows closing brace on different line from multi-line element + autocorrects closing brace on same line as last element + detects closing brace on same line as last multiline element + same_line style + opening brace on same line as first element + autocorrects closing brace on different line as last element + allows closing brace on same line from last element + detects closing brace on different line from multiline element + allows closing brace on same line as multi-line element + opening brace on separate line from first element + allows closing brace on same line as last element + detects closing brace on different line from last element + allows closing brace on same line as last multiline element + symmetrical style + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last multiline element + allows closing brace on separate line from last element + opening brace on same line as first element + allows closing brace on same line as last element + autocorrects closing brace on different line from last element + detects closing brace on different line from last element + allows closing brace on same line as last multiline element -RuboCop::Cop::Layout::EmptyLineBetweenDefs - accepts a nested def - registers an offense for adjacent one-liners by default - accepts a def that follows an empty line and then a comment - finds offenses in inner classes - registers an offense for multiple one-liners on the same line - accepts the first def without leading empty line in a class - accepts a def that follows a line with code - accepts a def that is the first of a module - autocorrects when there are too many new lines - doesn't allow more than the required number of newlines - accepts a def that follows code and a comment - treats lines with whitespaces as blank - EmptyLineBetweenClassDefs - registers offense when no empty lines between class and method definitions - when disabled - does not register offense - with AllowAdjacentOneLineDefs enabled - does not register offense - EmptyLineBetweenModuleDefs - registers offense when no empty lines between module and method definitions - when disabled - does not register offense - when there are only comments between defs - registers an offense - class methods - adjacent class methods - registers an offense for missing blank line between methods - mixed instance and class methods - registers an offense for missing blank line between methods - conditional method definitions - accepts defs inside a conditional without blank lines in between - registers an offense for consecutive defs inside a conditional - when a maximum of empty lines is specified - finds no offense for no empty line - finds an offense for two empty lines - finds no offense for one empty line - when multiple lines between defs are allowed - treats lines with whitespaces as blank - registers an offense and corrects when there are too many new lines - when empty lines between classes and modules together - registers offense when no empty lines between module and method definitions - endless methods - with AllowAdjacentOneLineDefs: true - does not register an offense - between regular and endless methods - registers an offense and corrects - with AllowAdjacentOneLineDefs: false - registers an offense and corrects - between endless and regular methods - registers an offense and corrects - between endless class method and regular class methods - registers an offense and corrects - between endless class method and regular methods - registers an offense and corrects - when AllowAdjacentOneLineDefs is enabled - accepts adjacent one-liners - registers an offense for adjacent defs if some are multi-line +RuboCop::Cop::Style::StringLiteralsInInterpolation + configured with single quotes preferred + accepts double quotes on a broken static string + can handle a built-in constant parsed as string + registers an offense for double quotes within embedded expression + accepts double quotes on a static string + registers an offense for double quotes within embedded expression in a heredoc string + can handle character literals + accepts double quotes on static strings within a method + configured with double quotes preferred + registers an offense for single quotes within embedded expression in a heredoc string + registers an offense for single quotes within embedded expression + when configured with a bad value + fails + +RuboCop::Cop::Style::AccessModifierDeclarations + when `group` is configured + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + accepts when #{access_modifier} is a hash literal value + accepts when using only #{access_modifier} + does not registers an offense when using #{access_modifier} in a block + does not offend when public is not inlined + does not registers an offense when using #{access_modifier} in a block + accepts when using only #{access_modifier} + accepts when #{access_modifier} is a hash literal value + offends when module_function is inlined with a method + offends when public is inlined with a method + does not offend when private is not inlined + does not offend when public is not inlined and has a comment + accepts when #{access_modifier} is a hash literal value + accepts when using only #{access_modifier} + accepts when using only #{access_modifier} + offends when private is inlined with a method + offends when protected is inlined with a method + does not offend when private is not inlined and has a comment + does not offend when protected is not inlined + does not registers an offense when using #{access_modifier} in a block + does not offend when protected is not inlined and has a comment + accepts when #{access_modifier} is a hash literal value + does not registers an offense when using #{access_modifier} in a block + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + does not offend when module_function is not inlined and has a comment + does not offend when module_function is not inlined + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + when method is modified by inline modifier + registers and autocorrects an offense + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method is modified by inline modifier where group modifier already exists + registers and autocorrects an offense + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when non-existent method is modified by inline modifier with disallowed symbol + registers an offense but does not autocorrect it + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method has comments + registers and autocorrects an offense + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method is modified by inline modifier where group modifier already exists + registers and autocorrects an offense + when method is modified by inline modifier where group modifier already exists + registers and autocorrects an offense + when non-existent method is modified by inline modifier with disallowed symbol + registers an offense but does not autocorrect it + when method has comments + registers and autocorrects an offense + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method is modified by inline modifier + registers and autocorrects an offense + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method is modified by inline modifier with disallowed symbol + registers and autocorrects an offense + when non-existent method is modified by inline modifier with disallowed symbol + registers an offense but does not autocorrect it + when method is modified by inline modifier where group modifier already exists + registers and autocorrects an offense + when method is modified by inline modifier + registers and autocorrects an offense + when non-existent method is modified by inline modifier with disallowed symbol + registers an offense but does not autocorrect it + when method has comments + registers and autocorrects an offense + when method is modified by inline modifier with disallowed symbol + registers and autocorrects an offense + when method is modified by inline modifier with disallowed symbol + registers and autocorrects an offense + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when method has comments + registers and autocorrects an offense + when method is modified by inline modifier with disallowed symbol + registers and autocorrects an offense + when method is modified by inline modifier + registers and autocorrects an offense + when `inline` is configured + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + offends when module_function is not inlined + does not offend when module_function is inlined with a symbol + does not offend when protected is inlined with a symbol + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + does not offend when public is inlined with a symbol + does not offend when public is inlined with a method + does not offend when private is inlined with a method + does not offend when module_function is inlined with a method + accepts when #{access_modifier} is a hash literal value + offends when protected is not inlined + accepts when #{access_modifier} is a hash literal value + offends when private is not inlined + accepts when #{access_modifier} is a hash literal value + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + does not offend when private is inlined with a symbol + offends when public is not inlined and has a comment + offends when public is not inlined + accepts when #{access_modifier} is a hash literal value + registers an offense for correct + multiple opposite styles of #{access_modifier} usage + offends when module_function is not inlined and has a comment + does not offend when protected is inlined with a method + offends when private is not inlined and has a comment + offends when protected is not inlined and has a comment + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when methods are modified by group modifier + registers and autocorrects an offense + when methods are modified by group modifier + registers and autocorrects an offense + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when methods are modified by group modifier + registers and autocorrects an offense + allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + when methods are modified by group modifier + registers and autocorrects an offense + do not allow access modifiers on symbols + accepts when argument to #{access_modifier} is a symbol + +RuboCop::Formatter::JUnitFormatter + #file_finished + displays an offense for `classname='test_2` in parsable text + displays an offense for `classname='test_1` in parsable text + displays a non-offense element in parsable text + displays end of parsable text + displays start of parsable text + +RuboCop::Cop::Style::OptionHash + registers an offense + when the last argument is a non-options-hash optional hash + does not register an offense + when there are no arguments + does not register an offense + permitted list + ignores if the method is permitted + when the last argument is an options hash named something else + does not register an offense + when the argument name is in the list of suspicious names + registers an offense + when passing options hash to super + does not register an offense when call to super is in a nested block + does not register an offense when code exists before call to super + does not register an offense + +RuboCop::Cop::Layout::LineEndStringConcatenationIndentation + when EnforcedStyle is aligned + accepts string literal with line break concatenated with other string + accepts indented strings in implicit return statement of a method definition after other statement + accepts indented strings in implicit return statement of a method definition + registers an offense for aligned strings in an if/elsif/else statement + accepts a heredoc string ... + registers an offense for unaligned strings in hash literal values + accepts a heredoc string with interpolation + accepts indented strings in implicit return statement of a singleton method definition + accepts indented strings in ordinary statement + registers an offense for indented string + accepts single line string literal concatenation + accepts indented strings in implicit return statement of a block + registers an offense for third part of a string if it is aligned only with the first + accepts a multiline string literal + accepts aligned strings in method call + accepts an empty heredoc string with interpolation + for assignment with x ||= + accepts aligned strings + registers an offense for indented strings + for assignment with $x = + registers an offense for indented strings + accepts aligned strings + for assignment with @x = + accepts aligned strings + registers an offense for indented strings + for assignment with x += + registers an offense for indented strings + accepts aligned strings + for assignment with x = + accepts aligned strings + registers an offense for indented strings + for assignment with X = + registers an offense for indented strings + accepts aligned strings + when EnforcedStyle is indented + accepts an empty heredoc string with interpolation + accepts indented strings in implicit return statement of a method definition after other statement + registers an offense for aligned strings in an if/elsif/else statement + accepts indented strings in implicit return statement of a method definition + registers an offense for unaligned third part of string + accepts indented strings + accepts indented strings in implicit return statement of a block + accepts a heredoc string with interpolation + accepts a heredoc string ... + registers an offense for aligned strings in hash literal values + registers an offense for aligned string + accepts single line string literal concatenation + accepts indented strings in ordinary statement + accepts string literal with line break concatenated with other string + accepts a multiline string literal + accepts indented strings in implicit return statement of a singleton method definition + for assignment with x += + registers an offense for aligned strings + accepts indented strings + for assignment with $x = + registers an offense for aligned strings + accepts indented strings + when IndentationWidth is 1 + accepts indented strings + for assignment with x = + registers an offense for aligned strings + accepts indented strings + for assignment with x ||= + registers an offense for aligned strings + accepts indented strings + for assignment with X = + registers an offense for aligned strings + accepts indented strings + for assignment with @x = + registers an offense for aligned strings + accepts indented strings + +RuboCop::Cop::EnforceSuperclass + registers an offense for single-line definitions + registers an offense for models that subclass ::ActiveRecord::Base + registers an offense for top-level constant ::Class.new definition + registers an offense for models that subclass ActiveRecord::Base + registers an offense for model defined using top-level + registers an offense for Class.new definition + when MyModel subclasses ApplicationRecord + behaves like no offense + registers no offenses for `class MyModel < ApplicationRecord; end` + behaves like no offense + registers no offenses for `MyModel = ::Class.new(::ApplicationRecord) do +end +MyModel = ::Class.new(::ApplicationRecord) +` + behaves like no offense + registers no offenses for `class MyModel < ::ApplicationRecord; end` + behaves like no offense + registers no offenses for `MyModel = Class.new(ApplicationRecord) do +end +MyModel = Class.new(ApplicationRecord) +` + when ApplicationRecord subclasses ActiveRecord::Base + behaves like no offense + registers no offenses for `::ApplicationRecord = Class.new(ActiveRecord::Base) do; end +` + behaves like no offense + registers no offenses for `class ::ApplicationRecord < ActiveRecord::Base; end` + behaves like no offense + registers no offenses for `::ApplicationRecord = ::Class.new(::ActiveRecord::Base) do; end +` + behaves like no offense + registers no offenses for `ApplicationRecord = Class.new(::ActiveRecord::Base) do; end +` + behaves like no offense + registers no offenses for `::ApplicationRecord = ::Class.new(::ActiveRecord::Base) +` + behaves like no offense + registers no offenses for `ApplicationRecord = Class.new(ActiveRecord::Base) +` + behaves like no offense + registers no offenses for `ApplicationRecord = Class.new(ActiveRecord::Base) do; end +` + behaves like no offense + registers no offenses for `class ApplicationRecord < ActiveRecord::Base; end` + +RuboCop::Cop::Style::StaticClass + does not register an offense for modules + does not register an offense when class includes/prepends a module + does not register an offense when class has instance method + registers an offense when class has assignments along with class methods + does not register an offense when class has `class << self` with macro calls + registers an offense when class has `class << self` with class methods + registers an offense when class has only class method + does not register an offense when class is empty + does not register an offense when class has a parent + registers an offense when class extends a module + does not register an offense when class has macro-like method + +RuboCop::Cop::Layout::TrailingEmptyLines + when EnforcedStyle is final_blank_line + registers an offense for final newline + autocorrects missing newline + registers an offense for multiple trailing blank lines + accepts final blank line + registers an offense for no final newline + autocorrects missing blank line + registers an offense for multiple blank lines in an empty file + when EnforcedStyle is final_newline + accepts final newline + autocorrects even if some lines have space + registers an offense for no final newline after assignment + registers an offense for multiple blank lines in an empty file + accepts an empty file + registers an offense for no final newline after block comment + accepts final blank lines if they come after __END__ + accepts final blank lines if they come after __END__ in empty file + registers an offense for multiple trailing blank lines + +RuboCop::Cop::Metrics::BlockNesting + accepts if/elsif + accepts `Max` levels of nesting + nested `until` + registers an offense + `Max + 2` levels of `if` nesting + registers an offense + nested `for` + registers an offense + Multiple nested `ifs` at same level + registers 2 offenses + `Max + 1` levels of `if` nesting + registers an offense + nested `case` + registers an offense + nested modifier `until` + registers an offense + nested `rescue` + registers an offense + nested `while` + registers an offense + when CountBlocks is false + accepts nested multiline blocks + accepts nested inline blocks + nested modifier `while` + registers an offense + when CountBlocks is true + nested inline block + registers an offense + nested multiline block + registers an offense + +RuboCop::Cop::Bundler::GemVersion + when EnforcedStyle is set to forbidden + does not flag gems included in AllowedGems metadata + does not flag gems without a specified version + flags gems that specify a gem version + when EnforcedStyle is set to required (default) + flags gems that do not specify a version + does not flag gems with a specified version + does not flag gems included in AllowedGems metadata + +RuboCop::Cop::Bundler::InsecureProtocolSource + registers an offense when using `source :rubyforge` + registers an offense when using `source :rubygems` + registers an offense when using `source :gemcutter` + does not register an offense when using `source 'https://rubygems.org'` + when `AllowHttpProtocol: false` + registers an offense when using `source 'http://rubygems.org'` + when `AllowHttpProtocol: true` + does not register an offense when using `source 'http://rubygems.org'` + +RuboCop::Cop::Lint::NonAtomicFileOperation + does not register an offense when not an exist check + registers an offense when use `FileTest.exist?` before force creating file + does not register an offense when using `FileTest.exist?` with `if` condition that has `else` branch + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use file existence checks `if` by postfix before removing file + registers an offense when use `FileTest.exist?` before creating file with an option `force: true` + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` with negated `if` before creating file + registers an offense when use `FileTest.exist?` before force creating file + does not register an offense when using complex conditional with `||` + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` before remove file + does not register an offense when processing other than file operations + registers an offense when use `FileTest.exist?` before creating file + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` before force creating file + does not register an offense when use `FileTest.exist?` before remove recursive file + does not register an offense when not checking for the existence + does not register an offense when using complex conditional with `&&` + does not register an offense when use `FileTest.exist?` before remove recursive file + registers an offense when use `FileTest.exist?` before force remove file + does not register an offense when use `FileTest.exist?` before creating file with an option `force: false` + registers an offense when using `FileTest.exist?` as a condition for `elsif` + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use file existence checks `unless` by postfix before creating file + registers an offense when use `FileTest.exists?` before creating file + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` before creating file with an option not `force` + registers an offense when use `FileTest.exist?` before force remove file + does not register an offense when not a method of file operation + does not register an offense when checking for the existence of different files + registers an offense when use `FileTest.exist?` before remove file + registers an offense when use `FileTest.exist?` before remove file + +RuboCop::Cop::Gemspec::DeprecatedAttributeAssignment + behaves like deprecated attributes with addition + registers and corrects an offense when using `spec.rubygems_version +=` + registers and corrects an offense when using `s.rubygems_version +=` + behaves like deprecated attributes + registers and corrects an offense when using `s.rubygems_version =` + does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` + does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable + registers and corrects an offense when using `spec.rubygems_version =` + behaves like deprecated attributes + registers and corrects an offense when using `spec.rubygems_version =` + registers and corrects an offense when using `s.rubygems_version =` + does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` + does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable + behaves like deprecated attributes + does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` + registers and corrects an offense when using `spec.rubygems_version =` + does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable + registers and corrects an offense when using `s.rubygems_version =` + behaves like deprecated attributes + does not register an offense when using `s.rubygems_version =` outside `Gem::Specification.new` + registers and corrects an offense when using `s.rubygems_version =` + registers and corrects an offense when using `spec.rubygems_version =` + does not register an offense when using `rubygems_version =` and receiver is not `Gem::Specification.new` block variable + +RuboCop::Cop::Metrics::AbcSize + when Max is 1.3 + reports size and max as <1, 1, 4> 4.24/1.3 + when Max is 0 + registers an offense for complex content including A, B, and C scores + registers an offense for an assignment of a local variable + registers an offense for a `define_method` + treats safe navigation method calls like regular method calls + a condition + accepts an empty method + registers an offense for an assignment of an element + accepts an empty `define_method` + registers an offense for an if modifier + when CountRepeatedAttributes is `false` + does not count repeated attributes + Ruby 2.7 + registers an offense for a `define_method` with numblock + when CountRepeatedAttributes is `true` + counts repeated attributes + when method is in list of allowed methods + when AllowedMethods is enabled + does not register an offense when defining an instance method + does not register an offense when using `define_method` + does not register an offense when defining a class method + when AllowedPatterns is enabled + does not register an offense when defining a class method + does not register an offense when defining an instance method + does not register an offense when using `define_method` + when Max is 2.3 + accepts a total score of 2.24 + when Max is 10.3 + reports size and max as <10, 10, 40> 42.43/10.3 + when Max is 2 + accepts two assignments + when Max is 100.321 + reports size and max as <100, 100, 400> 424.3/100.3 + when Max is 1000.3 + reports size and max as <1000, 1000, 4000> 4243/1000 + +RuboCop::Cop::Layout::SpaceInsideReferenceBrackets + with space inside empty brackets not allowed + accepts empty brackets with no space inside + registers an offense and corrects empty brackets with multiple spaces inside + registers an offense and corrects empty brackets with 1 space inside + registers an offense and corrects empty brackets with newline inside + with space inside empty braces allowed + registers offense and corrects empty brackets with no space inside + registers offense and corrects empty brackets with newline inside + registers offense and corrects empty brackets with more than one space inside + accepts empty brackets with space inside + when EnforcedStyle is space + accepts spaces in array brackets + does not register offense for reference brackets with spaces + registers an offense and corrects ref brackets with no trailing whitespace + accepts square brackets called with method call syntax + registers an offense and corrects third ref brackets with no leading whitespace + registers and corrects multiple offenses for multiple sets of ref brackets + registers an offense and corrects ref brackets with no leading whitespace + accepts an array as a reference object + does not register offense for ref bcts with spaces that assign + registers and corrects multiple offenses in one set of ref brackets + registers an offense and corrects when a reference bracket is assigned by another reference bracket with no trailing whitespace + registers an offense and corrects when a reference bracket with no trailing whitespace is assigned by another reference bracket + does not register offense for array literals + accepts square brackets as method name + registers an offense and corrects second ref brackets with no trailing whitespace + registers an offense and corrects second ref brackets with no leading whitespace + registers an offense and corrects when a reference bracket with no leading whitespace is assigned by another reference bracket + registers an offense and correct third ref brackets with no trailing whitespace + when EnforcedStyle is no_space + does not register offense for array literals + accepts extra spacing in array brackets + does not register offense for reference brackets with no spaces + registers multiple offenses and corrects one set of ref brackets + registers an offense and corrects when a reference bracket with a leading whitespace is assigned by another reference bracket + registers multiple offenses and corrects multiple sets of ref brackets + does not register offense for non-empty brackets with newline inside + accepts an array as a reference object + registers an offense and corrects third ref brackets with leading whitespace + registers an offense and corrects ref brackets with leading whitespace + registers an offense and corrects ref brackets with trailing whitespace + registers an offense and corrects when a reference bracket with a trailing whitespace is assigned by another reference bracket + accepts square brackets called with method call syntax + registers an offense and corrects outer ref brackets + registers an offense and corrects third ref brackets with trailing whitespace + registers an offense and corrects when a reference bracket is assigned by another reference bracket with trailing whitespace + registers an offense and corrects second ref brackets with trailing whitespace + registers an offense and corrects second ref brackets with leading whitespace + accepts square brackets as method name + does not register offense for ref bcts with no spaces that assign + register and correct multiple offenses for multiple sets of ref brackets + +RuboCop::Cop::Layout::CaseIndentation + when `when` is on the same line as `case` + registers an offense but does not autocorrect + with EnforcedStyle: case + with IndentOneStep: false + `case` ... `when` + registers an offense and corrects a `when` clause that is indented deeper than `case` + accepts a `when` clause that's equally indented with `case` + doesn't get confused by strings with `case` in them + doesn't get confused by symbols named `case` or `when` + accepts correctly indented whens in complex combinations + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + registers an offense and corrects assignment indented some other way + registers an offense and corrects assignment indented as end + accepts a correctly indented assignment + registers an offense and corrects correct + opposite style + `case` ... `in` + registers an offense and corrects an `in` clause that is indented deeper than `case` + accepts an `in` clause that's equally indented with `case` + doesn't get confused by strings with `case` in them + doesn't get confused by symbols named `case` or `in` + accepts correctly indented whens in complex combinations + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + registers an offense and corrects assignment indented some other way + accepts a correctly indented assignment + registers an offense and corrects correct + opposite style + registers an offense and corrects assignment indented as `end` + with IndentOneStep: true + `case` ... `when` + registers an offense and corrects a `when` clause that is equally indented with `case` + accepts a `when` clause that's 2 spaces deeper than `case` + regarding assignment where the right hand side is a `case` + registers an offense and corrects an assignment indented some other way + accepts a correctly indented assignment + with everything on a single line + does not register an offense + when indentation width is overridden for this cop only + respects cop-specific IndentationWidth + `case` ... `in` + registers an offense and corrects an `in` clause that is equally indented with `case` + accepts an `in` clause that's 2 spaces deeper than `case` + when indentation width is overridden for this cop only + respects cop-specific IndentationWidth + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + accepts a correctly indented assignment + registers an offense and corrects an assignment indented some other way + with EnforcedStyle: end + with IndentOneStep: false + `case` ... `when` + `when` and `end` same line + does not register an offense + regarding assignment where the right hand side is a `case` + accepts a correctly indented assignment + registers an offense and corrects an assignment indented some other way + `else` and `end` same line + does not register an offense + with everything on a single line + does not register an offense + `case` ... `in` + `in` and `end` same line + does not register an offense + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + accepts a correctly indented assignment + registers an offense and corrects an assignment indented some other way + with IndentOneStep: true + `case` ... `when` + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + accepts a correctly indented assignment + registers an offense and corrects an assignment indented some other way + registers an offense and corrects an assignment indented as `case` + `case` ... `in` + with everything on a single line + does not register an offense + regarding assignment where the right hand side is a `case` + registers an offense and corrects an assignment indented some other way + accepts a correctly indented assignment + registers an offense and corrects an assignment indented as `case` + +RuboCop::Cop::Style::ModuleFunction + when enforced style is `module_function` + accepts for `extend self` in a module with declarative private + accepts `extend self` in a class + registers an offense for `extend self` in a module + accepts for `extend self` in a module with private methods + when enforced style is `extend_self` + accepts module_function with an argument + registers an offense for `module_function` without an argument + when enforced style is `forbidden` + accepts `extend self` in a class + registers an offense for `module_function` without an argument + registers an offense for `extend self` + in a module with declarative private + in a module with private methods + in a module + +RuboCop::Cop::Lint::LiteralAsCondition + registers an offense for `not :sym` + accepts literal {} in non-toplevel and/or + registers an offense for literal {} in post-loop until + registers an offense for literal {} in if + registers an offense for literal {} in && + accepts literal 1 if it's not an and/or operand + registers an offense for literal [1] in a when of a case without anything after case keyword + registers an offense for literal 2.0 in && + accepts literal [1] in a when of a case with something after case keyword + registers an offense for `not {}` + registers an offense for literal 2.0 in a when of a case without anything after case keyword + accepts literal 1 in a when of a case with something after case keyword + registers an offense for literal 1 in a when of a case without anything after case keyword + registers an offense for literal :"#{a}" in while + accepts literal :"#{a}" in non-toplevel and/or + accepts `false` literal in `until` + registers an offense for literal :sym in until + registers an offense for `!{}` + accepts literal {} in a when of a case with something after case keyword + registers an offense for literal :"#{a}" in complex cond + registers an offense for literal {} in complex cond + registers an offense for literal 2.0 in complex ! + registers an offense for literal :"#{a}" in post-loop until + registers an offense for literal :"#{a}" in a when of a case without anything after case keyword + registers an offense for literal :sym in while + registers an offense for literal 1 in complex ! + registers an offense for literal :"#{a}" in case + accepts `true` literal in `while` + registers an offense for literal :sym in complex cond + registers an offense for literal 1 in ! + registers an offense for literal :"#{a}" in if + accepts literal 1 in non-toplevel and/or + registers an offense for literal 1 in && + registers an offense for literal [1] in if + registers an offense for literal 2.0 in while + registers an offense for literal 1 in complex cond + registers an offense for `!2.0` + registers an offense for literal :sym in if + accepts literal 2.0 in a when of a case with something after case keyword + accepts literal [1] if it's not an and/or operand + registers an offense for literal [1] in case + accepts literal :"#{a}" if it's not an and/or operand + registers an offense for literal 1 in case + registers an offense for literal {} in case + accepts array literal in case, if it has nested non-literal element + registers an offense for `not :"#{a}"` + registers an offense for literal 1 in if + accepts array literal in case, if it has non-literal elements + registers an offense for literal 2.0 in post-loop while + registers an offense for literal {} in while + registers an offense for literal {} in post-loop while + registers an offense for literal 2.0 in until + registers an offense for literal 2.0 in complex cond + registers an offense for literal :"#{a}" in until + registers an offense for literal :sym in a when of a case without anything after case keyword + registers an offense for literal {} in complex ! + registers an offense for `!1` + registers an offense for literal [1] in until + registers an offense for literal 2.0 in if + accepts `false` literal in post-loop `until` + accepts literal :sym in non-toplevel and/or + registers an offense for literal [1] in while + registers an offense for literal :sym in ! + accepts literal 2.0 in non-toplevel and/or + registers an offense for literal :"#{a}" in && + registers an offense for literal 2.0 in case + registers an offense for literal :sym in post-loop while + registers an offense for `not [1]` + accepts literal [1] in non-toplevel and/or + accepts literal :sym in a when of a case with something after case keyword + registers an offense for `!:sym` + registers an offense for literal [1] in post-loop while + registers an offense for literal :sym in post-loop until + registers an offense for literal :"#{a}" in complex ! + registers an offense for literal {} in ! + registers an offense for `!:"#{a}"` + registers an offense for literal 1 in while + registers an offense for literal :"#{a}" in post-loop while + accepts `true` literal in post-loop `while` + accepts literal :"#{a}" in a when of a case with something after case keyword + registers an offense for literal 1 in until + registers an offense for literal :sym in complex ! + accepts literal 2.0 if it's not an and/or operand + registers an offense for literal 1 in post-loop while + accepts literal {} if it's not an and/or operand + registers an offense for literal 2.0 in ! + registers an offense for case with a primitive array condition + registers an offense for `not 1` + registers an offense for literal [1] in complex ! + accepts dstr literal in case + registers an offense for `not 2.0` + registers an offense for literal :sym in case + registers an offense for literal [1] in ! + accepts literal :sym if it's not an and/or operand + registers an offense for literal [1] in && + registers an offense for literal {} in until + registers an offense for literal 2.0 in post-loop until + registers an offense for literal [1] in complex cond + registers an offense for literal :sym in && + registers an offense for literal [1] in post-loop until + registers an offense for literal 1 in post-loop until + registers an offense for literal :"#{a}" in ! + registers an offense for `![1]` + registers an offense for literal {} in a when of a case without anything after case keyword + >= Ruby 2.7 + accepts literal :"#{a}" in a when of a case match + registers an offense for literal :"#{a}" in case match without a match var + accepts an offense for literal :"#{a}" in case match with a match var + >= Ruby 2.7 + registers an offense for literal :sym in case match without a match var + accepts literal :sym in a when of a case match + accepts an offense for literal :sym in case match with a match var + >= Ruby 2.7 + registers an offense for literal [1] in case match without a match var + accepts literal [1] in a when of a case match + accepts an offense for literal [1] in case match with a match var + >= Ruby 2.7 + accepts an offense for case match with a match var + accepts array literal in case match, if it has non-literal elements + registers an offense for case match with a primitive array condition + accepts array literal in case match, if it has nested non-literal element + accepts dstr literal in case match + >= Ruby 2.7 + accepts an offense for literal {} in case match with a match var + registers an offense for literal {} in case match without a match var + accepts literal {} in a when of a case match + >= Ruby 2.7 + registers an offense for literal 1 in case match without a match var + accepts literal 1 in a when of a case match + accepts an offense for literal 1 in case match with a match var + >= Ruby 2.7 + registers an offense for literal 2.0 in case match without a match var + accepts an offense for literal 2.0 in case match with a match var + accepts literal 2.0 in a when of a case match + +RuboCop::Cop::Lint::AmbiguousOperator + when using safe navigation operator with a unary operator + does not register an offense + with `-` unary operator in the first argument + with parentheses around the operator + does not register an offense + without parentheses + without whitespaces on the right of the operator + registers an offense and corrects + with a whitespace on the right of the operator + does not register an offense + with `+` unary operator in the first argument + with parentheses around the operator + does not register an offense + without parentheses + without whitespaces on the right of the operator + registers an offense and corrects + without whitespaces on the right of the operator when a method with no arguments is used in advance + registers an offense and corrects + with a whitespace on the right of the operator + does not register an offense + with a keyword splat operator in the first argument + without parentheses + with a whitespace on the right of the operator + does not register an offense + without whitespaces on the right of the operator + registers an offense and corrects + with parentheses around the keyword splat operator + does not register an offense + with a block ampersand in the first argument + with parentheses around the block argument + does not register an offense + without parentheses + without whitespaces on the right of the operator + registers an offense and corrects + with a whitespace on the right of the operator + does not register an offense + with a splat operator in the first argument + without parentheses + with a whitespace on the right of the operator + does not register an offense + without whitespaces on the right of the operator + registers an offense and corrects + with parentheses around the splatted argument + does not register an offense + +RuboCop::Cop::Bundler::GemComment + when investigating Ruby files + does not register any offenses + when investigating Gemfiles + and the gem is commented on the same line + does not register any offenses + and a gem has no comment + registers an offense + and the gem is permitted + does not register any offenses + and the file is empty + does not register any offenses + and the file contains source and group + does not register any offenses + when the "OnlyFor" option is set + including "version_specifiers" + when a gem is commented + does not register an offense + when a gem is uncommented and has no version specified + does not register an offense + when a gem is uncommented and has options but no version specifiers + does not register an offense + when a gem is uncommented and has a version specifier along with other options + registers an offense + when a gem is uncommented and has a version specifier + registers an offense + when a gem is uncommented and has multiple version specifiers + registers an offense + including one or more option names but not "version_specifiers" + when a gem is uncommented and has a version specifier but none of the specified options + does not register an offense + when a gem is uncommented and has one of the specified options + registers an offense + when a gem is uncommented and contains only options not specified + does not register an offense + including "restrictive_version_specifiers" + when a gem is commented + does not register an offense + when a gem is uncommented and has a frozen version specifier + registers an offense + when a gem is uncommented and has options but no version specifiers + does not register an offense + when a gem is uncommented and has a version specifier without operator + registers an offense + when a gem is uncommented and has both minimum and non-minimum version specifier + registers an offense + when a gem is uncommented and has a non-minimum version specifier with a leading space + registers an offense + when a gem is uncommented and has no version specified + does not register an offense + when a gem is uncommented and has a version specifier along with other options + registers an offense + when a gem is uncommented and has a pessimistic version specifier + registers an offense + when a gem is uncommented and has only a minimum version specifier + does not register an offense + and the gem is commented + does not register any offenses + +RuboCop::Cop::Corrector + #rewrite + allows insertion after a source range + allows removal of characters preceding range + raises a useful error if not given a node or a range + allows removal of characters from range ending + allows replacement of a range + allows removal of a range + allows insertion before a source range + accepts a node instead of a range + allows insertion before and after a source range + allows removal of characters from range beginning + when range is from incorrect source + raises exception from remove_trailing + raises exception from replace + raises exception from remove_preceding + raises exception from remove_leading + raises exception from insert_after + raises exception from remove + raises exception from insert_before + +RuboCop::Cop::Style::MapToHash + >= Ruby 2.6 + when chained further + registers an offense and corrects + for `map.to_h` with block arity 2 + registers an offense and corrects + for `collect.to_h` with block arity 2 + registers an offense and corrects + `collect.to_h` with a block on `to_h` + registers an offense but does not correct + when chained further + registers an offense and corrects + when the receiver is an array + registers an offense and corrects + `map` and `map.to_h` with newlines + registers an offense and corrects with newline removal + `map` without `to_h` + does not register an offense + for `collect.to_h` with block arity 1 + registers an offense and corrects + when the receiver is an hash + registers an offense and corrects + for `map.to_h` with block arity 1 + registers an offense and corrects + `map.to_h` with a block on `to_h` + registers an offense but does not correct + when the receiver is an hash + registers an offense and corrects + `map` and `collect.to_h` with newlines + registers an offense and corrects with newline removal + when the receiver is an array + registers an offense and corrects + `collect` without `to_h` + does not register an offense + +RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault + when EnforcedStyle is space + registers an offense and corrects assigning empty string without space + registers an offense and corrects default value assignment where first is partially right without space + registers an offense and corrects assignment of empty list without space + registers an offense and corrects missing space for arguments with unary operators + registers an offense and corrects default value assignment without space + accepts default value assignment with space + accepts default value assignment with spaces and unary + operator + when EnforcedStyle is no_space + registers an offense and corrects assignment of empty string with space + accepts default value assignment without space + registers an offense and corrects default value assignment with space + registers an offense and corrects assignment of empty list with space + +RuboCop::Cop::Naming::ClassAndModuleCamelCase + allows module_parent method + is not fooled by qualified names + registers an offense for underscore in class and module name + accepts CamelCase names + custom allowed names + does not register offense for multiple allowed names + +RuboCop::Cop::Style::MultilineInPatternThen + >= Ruby 2.7 + registers an offense for empty `in` statement with `then` + doesn't register an offense for empty `in` statement without `then` + registers an offense for multiline (one line in a body) `in` statement with `then` + doesn't register an offense for multiline `in` statement with `then` followed by other lines + does not register an offense for array `when` statement with `then` + doesn't register an offense for multiline `in` statement without `then` + does not register an offense when line break for multiple candidate values of `in` + registers an offense for multiline (two lines in a body) `in` statement with `then` + doesn't register an offense for singleline `in` statement with `then` + registers an offense when one line for multiple candidate values of `in` + autocorrects when the body of `in` branch starts with `then` + doesn't register an offense when `then` required for a body of `in` is used + does not register an offense for hash `in` statement with `then` + +RuboCop::Cop::Layout::LineLength + registers an offense for long line before __END__ but not after + accepts the first line if it is a shebang line + highlights excessive characters + accepts a line that's 80 characters wide + registers an offense for a line that's 81 characters wide + when AllowURI option is disabled + and all the excessive characters are part of a URL + registers an offense for the line + autocorrection + method definition + when over limit + adds an offense and autocorrects it + when under limit + does not add any offenses + no breakable collections + adds an offense and does not autocorrect it + HEREDOC + when over limit with semicolon + adds offense and does not autocorrect + comments + when over limit with semicolon + adds offense and does not autocorrect + method call + when two method calls + adds an offense only to outer and autocorrects it + when call with hash on same line + adds an offense only to outer and autocorrects it + when two together + does not add any offenses + with a hash with a too long first item + when not parenthesized + when on multiple lines + does not correct + when there are multiple elements + moves the 2nd element to a new line + when there is only one element + does not autocorrect + when the hash is parenthesized + corrects + when parenthesized + corrects + when over limit + adds an offense and autocorrects it + when nested method calls allows outer to get broken up first + adds offense and does not autocorrect + with a heredoc argument + does not break up the line + does not break up the line when parentheses are omitted + does not break up the line when a heredoc is used as the first element of an array + and the heredoc is after the line should split + can break up the line before the heredoc argument + and other arguments before the heredoc + can break up the line before the heredoc argument + with long argument list + registers an offense and autocorrects it + when under limit + does not add any offenses + when unparenthesized + when there are multiple arguments + splits the line after the first element + when there is one argument + does not autocorrect + multiple assignment + when over limit at right hand side + registers and corrects an offense + array + when already on two lines + does not add any offenses + when two arrays on two lines allows outer to get broken first + adds an offense only to inner and does not autocorrect it + when has inside array + adds an offense only to outer and autocorrects it + when under limit + does not add any offenses + when over limit + adds an offense and autocorrects it + long blocks + no spaces + adds an offense and does correct it + let block + adds an offense and does correct it + Ruby 2.7 + adds an offense for {} block does correct it + adds an offense for do-end block and does correct it + braces + adds an offense and does correct it + lambda syntax + when argument is enclosed in parentheses + registers an offense and corrects + when argument is not enclosed in parentheses + registers an offense and corrects + do/end + adds an offense for block with arguments and does correct it + adds an offense for block without arguments and does correct it + hash + when over limit because of a comment + adds an offense and does not autocorrect + when over limit and keys already on multiple lines + adds an offense and does not autocorrect + when over limit rocket + adds an offense and autocorrects it + when hash in method call + adds an offense only to outer and autocorrects it + when nested hashes on same line + adds an offense only to outer and autocorrects it + when over limit + adds an offense and autocorrects it + when under limit + does not add any offenses + when over limit rocket symbol + adds an offense and autocorrects it + when over limit and already on multiple lines long key + adds an offense and does not autocorrect + semicolon + semicolons inside string literal + adds offense and autocorrects elsewhere + when under limit + does not add any offenses + when over limit and many spaces around semicolon + adds offense and autocorrects it by breaking the semicolonbefore the hash + when over limit and many semicolons at the end + adds offense and does not autocorrectbefore the hash + when over limit and semicolon at end of line + adds offense and autocorrects it by breaking the first semicolonbefore the hash + when over limit and many semicolons + adds offense and autocorrects it by breaking the semicolonbefore the hash + semicolon inside string literal + adds offense and autocorrects elsewhere + when over limit + adds offense and autocorrects it by breaking the semicolonbefore the hash + when over limit and one semicolon at the end + adds offense and does not autocorrectbefore the hash + affecting by IndentationWidth from Layout\Tab + without AllowURI option + behaves like with tabs indentation + accepts a line that's including 1 tab with size 2 and 28 other characters + registers an offense for a line that's including 2 tab with size 2 and 28 other characters + with AllowURI option + accepts a line that's including URI with text + accepts a line that's including URI in quotes with text + accepts a line that's including URI + accepts a line that's including URI and exceeds by 1 char + behaves like with tabs indentation + registers an offense for a line that's including 2 tab with size 2 and 28 other characters + accepts a line that's including 1 tab with size 2 and 28 other characters + when line is indented with tabs + registers an offense for a long line + accepts a short line + when IgnoreCopDirectives is enabled + and the Rubocop directive causes an excessive line length + accepts the line + and has explanatory text + does not register an offense + and the Rubocop directive is excessively long + accepts the line + and the source is too long + highlights only the non-directive part + and the source contains non-directive #s as non-comment + registers an offense for the line + and the source contains non-directive # as comment + highlights only the non-directive part + when IgnoreCopDirectives is disabled + and the source is acceptable length + with an inline comment + highlights the excess comment + with a trailing RuboCop directive + registers an offense for the line + and the source is too long and has a trailing cop directive + highlights the excess source and cop directive + when AllowHeredoc option is enabled + accepts long lines in heredocs + when the source has no AST + does not crash + and only certain heredoc delimiters are permitted + rejects long lines in heredocs with not permitted delimiters + when AllowedPatterns option is set + only registers an offense for lines not matching the pattern + when AllowURI option is enabled + and the URL does not have a http(s) scheme + rejects the line + and the scheme has been configured + does not register an offense + and the URI is an argument + does not register an offense + and the excessive characters include part of a URL in braces and another word + registers an offense for the line + and the excessive characters include part of a URL and another word + registers an offense for the line + and the excessive characters include part of a URL in double quotes + does not include the quote as part of the offense + and an error other than URI::InvalidURIError is raised while validating a URI-ish string + does not crash + and the excessive characters include part of a URL and trailing whitespace + registers an offense for the line + and the excessive characters include a complete URL + registers an offense for the line + and the URL fits within the max allowed characters + registers an offense for the line + and the URI is assigned + does not register an offense + and all the excessive characters are part of a URL + accepts the line + and the URL is wrapped in single quotes + accepts the line + and the URL is wrapped in braces with title + accepts the line + and the URL is wrapped in braces + accepts the line + and the URL is wrapped in double quotes + accepts the line + +RuboCop::Cop::Lint::IdentityComparison + does not register an offense when using `==` for comparison between `object_id` and other + does not register an offense when rhs is `object_id` without receiver + registers an offense and corrects when using `==` for comparison between `object_id`s + does not register an offense when lhs is `object_id` without receiver + does not register an offense when using `==` + does not register an offense when a receiver that is not `object_id` uses `==` + +RuboCop::Cop::Lint::RegexpAsCondition + does not register an offense for a regexp literal outside conditions + registers an offense and corrects for a regexp literal in `if` condition + does not register an offense for a regexp literal with `=~` operator + +RuboCop::Cop::Style::ParenthesesAroundCondition + allows parens if the condition node is a modifier if op + allows parens if the condition node is a modifier until op + accepts parentheses if there is no space between the keyword and (. + allows parens if the condition node is a modifier unless op + registers an offense for parentheses around condition + allows parens if the condition node is a modifier rescue op + does not blow up when the condition is a ternary op + does not blow up for empty if condition + accepts parentheses around condition in a ternary + is not confused by parentheses in subexpression + is not confused by leading parentheses in subexpression + allows parens if the condition node is a modifier while op + does not register an offense when parentheses in multiple expressions separated by semicolon + does not blow up for empty unless condition + parentheses in multiline conditions are allowed + accepts parentheses around multiline condition + registers an offense for parentheses in single line condition + safe assignment is not allowed + does not accept variable assignment in condition surrounded with parentheses + does not accept element assignment in condition surrounded with parentheses + safe assignment is allowed + accepts variable assignment in condition surrounded with parentheses + accepts setter in condition surrounded with parentheses + accepts element assignment in condition surrounded with parentheses + parentheses in multiline conditions are not allowed + registers an offense for parentheses around multiline condition + +RuboCop::FileFinder + #find_file_upwards + returns a file to be found upwards + returns nil when file is not found + #find_last_file_upwards + returns nil when file is not found + returns the last file found upwards + +RuboCop::Cop::Lint::InheritException + when class inherits from `Exception` + with enforced style set to `standard_error` + registers an offense and corrects + when creating a subclass using Class.new + registers an offense and corrects + when inheriting a standard lib exception class that is not a subclass of `StandardError` + does not register an offense + with enforced style set to `runtime_error` + registers an offense and corrects + when creating a subclass using Class.new + registers an offense and corrects + when inheriting a standard lib exception class that is not a subclass of `StandardError` + does not register an offense + +RuboCop::Cop::InternalAffairs::NodeDestructuring + does not register an offense when receiver is named `array` + registers an offense when destructuring using a splat + when destructuring using `node.children` + registers an offense when receiver is named `send_node` + registers an offense when receiver is named `node` + +RuboCop::Cop::Lint::RedundantSafeNavigation + registers an offense and corrects when `&.` is used inside complex condition + does not register an offense when using `&.` with non-allowed method in condition + does not register an offense when using `&.` outside of conditions + registers an offense and corrects when `&.` is used inside `#{loop_type}` condition + registers an offense and corrects when `&.` is used inside `if` condition + registers an offense and corrects when `&.` is used inside `#{loop_type}` condition + registers an offense and corrects when `&.` is used inside `unless` condition + does not register an offense when using `&.respond_to?` with `nil` specific method as argument in condition + +RuboCop::Cop::Lint::EachWithObjectArgument + registers an offense for float argument + accepts a variable argument + registers an offense for bignum argument + accepts two arguments + accepts a string argument + registers an offense for fixnum argument + when using safe navigation operator + registers an offense for fixnum argument + +RuboCop::Cop::Security::MarshalLoad + allows using dangerous Marshal methods for deep cloning + does not register an offense Marshal methods under another namespace + registers an offense for using Marshal.load + does not register an offense for Marshal.dump + registers an offense for using Marshal.restore + +RuboCop::Cop::Lint::MixedRegexpCaptureTypes + registers an offense when both of named and numbered captures are used + does not register offense when using a Regexp cannot be processed by regexp_parser gem + does not register offense to a regexp with named capture only + does not register offense to a regexp with numbered capture only + does not register offense to a regexp with named capture and non-capturing group + when containing a non-regexp literal + does not register an offense when containing a ivar + does not register an offense when containing a lvar + does not register an offense when containing a constant + does not register an offense when containing a method + does not register an offense when containing a gvar + does not register an offense when containing a cvar + +RuboCop::Cop::Lint::UnderscorePrefixedVariableName + in a method calling `super` without arguments + when an underscore-prefixed argument is used explicitly + registers an offense + when an underscore-prefixed argument is not used explicitly + does not register an offense + in a method calling `binding` without arguments + when an underscore-prefixed argument is used explicitly + registers an offense + when an underscore-prefixed argument is not used explicitly + does not register an offense + when an underscore-prefixed block argument is used + registers an offense + registers an offense + when non-underscore-prefixed variable is used + does not register an offense + when an underscore-prefixed method argument is used + registers an offense + when an underscore-prefixed variable is reassigned + does not register an offense + when an underscore-prefixed keyword block argument is used + registers an offense + when AllowKeywordBlockArguments is set + does not register an offense + when an underscore-prefixed variable in top-level scope is used + registers an offense + when an underscore-prefixed variable is captured by a block + accepts + when an underscore-prefixed variable is used + registers an offense + in a method calling `binding` with arguments + when an underscore-prefixed argument is used explicitly + registers an offense + when an underscore-prefixed argument is not used + does not register an offense + in a method calling `super` with arguments + when an underscore-prefixed argument is used explicitly + registers an offense + when an underscore-prefixed argument is not used + does not register an offense + when an underscore-prefixed named capture variable is used + registers an offense + +RuboCop::Cop::Gemspec::RequireMFA + with rubygems_mfa_required: true + does not register an offense + when the specification has an non-hash metadata + registers an offense but does not correct + when metadata is set by key assignment + and `rubygems_mfa_required` is included + does not register an offense + and `rubygems_mfa_required` is not included + registers an offense + with rubygems_mfa_required: false by key access + registers an offense and corrects + when there are other metadata keys + and `rubygems_mfa_required` is not included + registers an offense and corrects + and `rubygems_mfa_required` is included + does not register an offense + when the gemspec is blank + does not register an offense + when the specification is blank + registers an offense and corrects + when the specification has a metadata hash but no rubygems_mfa_required key + registers an offense and corrects + with rubygems_mfa_required: false + registers an offense and corrects + +RuboCop::Cop::Style::SlicingWithRange + >= Ruby 2.7 + reports no offense for startless + >= Ruby 2.6 + reports no offense for excluding end + reports an offense for slicing from expression to ..-1 + reports an offense for slicing to ..-1 + reports no offense for array with range inside + reports no offense for other methods + <= Ruby 2.5 + reports no offense for array slicing with -1 + +RuboCop::Cop::InternalAffairs::ExampleHeredocDelimiter + when unexpected heredoc delimiter is used but heredoc body contains an expected delimiter line + does not register an offense + when unexpected heredoc delimiter is used at non RuboCop specific expectation + does not register an offense + when unexpected heredoc delimiter is used in single-line heredoc + registers an offense + when expected heredoc delimiter is used at RuboCop specific expectation + does not register an offense + when unexpected heredoc delimiter is used in multi-line heredoc + registers an offense + +RuboCop::Cop::Style::QuotedSymbols + configured with `single_quotes` + behaves like enforce single quotes + accepts double quotes when control characters are used + accepts double quotes when unicode control sequence is used + accepts single quotes with double quotes + registers an offense and corrects for an escaped quote within double quotes + accepts double quotes with single quotes + accepts double quotes with escape sequences + registers an offense and corrects for double quotes in hash keys + accepts single quotes + accepts double quotes when interpolating an instance variable + accepts double quotes when interpolating a global variable + accepts single quotes with line breaks + registers an offense and corrects escape characters properly + accepts unquoted symbols + accepts double quotes when interpolating a class variable + registers an offense and corrects for double quotes without interpolation + accepts single quoted symbol with an escaped quote + accepts double quotes with line breaks + accepts double quotes with some other special symbols + accepts double quotes with interpolation + hash with hashrocket style + corrects wrong quotes + accepts properly quoted symbols + configured with `double_quotes` + behaves like enforce double quotes + accepts double quotes with single quotes + accepts unquoted symbols + accepts double quoted symbol with an escaped quote + accepts double quotes with line breaks + registers an offense for single quotes + registers an offense and corrects escape characters properly + accepts double quotes with escape sequences + accepts single quotes with double quotes + registers an offense and corrects for an escaped quote within single quotes + accepts double quotes + accepts double quotes when interpolating a class variable + accepts single quotes with line breaks + accepts double quotes when interpolating a global variable + accepts double quotes when interpolating an instance variable + accepts double quotes with interpolation + hash with hashrocket style + corrects wrong quotes + accepts properly quoted symbols + configured with `same_as_string_literals` + when Style/StringLiterals is configured with single_quotes + behaves like enforce single quotes + accepts double quotes with some other special symbols + accepts double quotes when unicode control sequence is used + accepts single quotes with line breaks + accepts double quotes when interpolating an instance variable + accepts double quotes with interpolation + accepts double quotes with line breaks + registers an offense and corrects for double quotes without interpolation + accepts double quotes with escape sequences + registers an offense and corrects for double quotes in hash keys + accepts double quotes when interpolating a class variable + registers an offense and corrects escape characters properly + registers an offense and corrects for an escaped quote within double quotes + accepts single quotes with double quotes + accepts double quotes when interpolating a global variable + accepts double quotes with single quotes + accepts single quoted symbol with an escaped quote + accepts unquoted symbols + accepts single quotes + accepts double quotes when control characters are used + hash with hashrocket style + accepts properly quoted symbols + corrects wrong quotes + when Style/StringLiterals is disabled + behaves like enforce single quotes + accepts single quotes with line breaks + accepts double quotes with interpolation + accepts single quotes + registers an offense and corrects for double quotes in hash keys + accepts double quotes with line breaks + accepts double quotes when interpolating an instance variable + registers an offense and corrects for an escaped quote within double quotes + accepts double quotes with some other special symbols + accepts single quoted symbol with an escaped quote + registers an offense and corrects escape characters properly + accepts double quotes with escape sequences + accepts double quotes when interpolating a global variable + accepts single quotes with double quotes + accepts double quotes when control characters are used + accepts unquoted symbols + registers an offense and corrects for double quotes without interpolation + accepts double quotes when unicode control sequence is used + accepts double quotes when interpolating a class variable + accepts double quotes with single quotes + hash with hashrocket style + corrects wrong quotes + accepts properly quoted symbols + when Style/StringLiterals is configured with double_quotes + behaves like enforce double quotes + registers an offense and corrects for an escaped quote within single quotes + accepts double quotes with line breaks + accepts single quotes with line breaks + accepts single quotes with double quotes + accepts double quotes with single quotes + accepts double quotes when interpolating a global variable + accepts double quotes + accepts double quotes with escape sequences + accepts double quotes when interpolating a class variable + accepts unquoted symbols + accepts double quotes with interpolation + accepts double quotes when interpolating an instance variable + registers an offense and corrects escape characters properly + registers an offense for single quotes + accepts double quoted symbol with an escaped quote + hash with hashrocket style + corrects wrong quotes + accepts properly quoted symbols + +RuboCop::Cop::Layout::SpaceAfterColon + accepts hash rockets + accepts colon in ternary followed by space + accepts colons in symbols + registers an offense and corrects a keyword optional argument without a space + accepts hashes with a space after colons + accepts colons in strings + accepts colons denoting required keyword argument + accepts required keyword arguments + registers an offense and corrects colon without space after it + accepts if + Ruby >= 3.1 + does not register an offense colon without space after it when using hash value omission + accepts colons denoting hash value omission argument + +RuboCop::Cop::Commissioner + #investigate + traverses the AST and invoke cops specific callbacks + stores all errors raised by the cops + when a cop reports offenses + returns all offenses found by the cops + when given a force + passes the input params to all cops/forces that implement their own #investigate method + when passed :raise_error option + re-raises the exception received while processing + when passed :raise_cop_error option + re-raises the exception received while processing + traverses the AST with on_send / on_csend + for unrestricted cops + calls on_send all method calls + for a restricted cop + calls on_send for the right method calls + on both csend and send + calls on_send for the right method calls + when given a source with parsing errors + only calls on_other_file + +RuboCop::Cop::Lint::AssignmentInCondition + registers an offense for assignment after ||= in condition + does not blow up for empty if condition + registers an offense for gvar assignment in condition + accepts assignment in a block after || + accepts = in a block followed by method call + registers an offense for ivar assignment in condition + registers an offense for lvar assignment in condition + registers an offense for lvar assignment in until condition + registers an offense for = in condition inside a block + accepts ||= in condition + accepts = in a block that is called in a condition + registers an offense for lvar assignment in while condition + registers an offense for clvar assignment in condition + registers an offense for assignment after == in condition + accepts == in condition + registers an offense for assignment methods + does not blow up for empty unless condition + registers an offense for collection element assignment in condition + registers an offense for constant assignment in condition + safe assignment is not allowed + does not accept []= in condition surrounded with braces + does not accept = in condition surrounded with braces + safe assignment is allowed + accepts []= in condition surrounded with braces + accepts = in condition surrounded with braces + +RuboCop::Cop::Style::AndOr + when style is always + also warns on until (and) + also warns on non short-circuit (or) (unless) + autocorrects "and" with an Enumerable accessor on either side + autocorrects "and" with && in method calls (3) + autocorrects "or" with || in method calls (3) + autocorrects "and" with && and adds parentheses to expr + autocorrects "or" with an assignment on the right + autocorrects "or" with || in method calls (2) + autocorrects "and" with && in method calls + autocorrects "and" with && in method calls (2) + warns on short-circuit (and) + also warns on while (and) + autocorrects "or" inside def + autocorrects "or" with || and doesn't add extra parentheses + warns on short-circuit (or) + autocorrects "or" with || in method calls + autocorrects "or" with || in method calls (4) + also warns on while (or) + autocorrects "and" with && in method calls (4) + also warns on until (or) + autocorrects "or" with || and adds parentheses to expr + registers an offense for "and" + autocorrects "or" with an assignment on the left + autocorrects "and" inside def + also warns on non short-circuit (and) (unless) + also warns on non short-circuit (and) + autocorrects "and" with && and doesn't add extra parentheses + registers an offense for "or" + also warns on non short-circuit (or) + with two predicate methods with args without spaces on right + autocorrects "and" with && and adds parens + autocorrects "or" with || and adds parens + when `and` precedes `or` + registers an offense and corrects + within a nested begin node + autocorrects "and" with && and adds parens + with predicate method with arg without space on right + autocorrects "or" with || and adds parens + autocorrects "and" with && and adds parens + with !variable on left + doesn't crash and burn + with obj.method= arg on left + autocorrects "and" with && and adds parens + when left hand side is a comparison method + autocorrects "and" with && and adds parens + within a nested begin node with one child only + autocorrects "and" with && and adds parens + with !obj.method arg on right + autocorrects "and" with && and adds parens + when `or` precedes `and` + registers an offense and corrects + with obj.method = arg on left + autocorrects "and" with && and adds parens + with `not` expression on right + autocorrects "and" with && and adds parens + with one predicate method without space on right and another method + autocorrects "or" with || and adds parens + autocorrects "and" with && and adds parens + when `and` precedes `||` + registers an offense and corrects + with !obj.method arg on left + autocorrects "and" with && and adds parens + with `not` expression on left + autocorrects "and" with && and adds parens + with a file which contains __FILE__ + autocorrects "or" with || + when `or` precedes `&&` + registers an offense and corrects + when style is conditionals + registers an offense for "or" in post-while condition + accepts && inside of conditional + registers an offense for "or" in if condition + accepts || inside of conditional + registers an offense for "or" in while condition + accepts "and" outside of conditional + accepts "or" outside of conditional + registers an offense for "and" in while condition + registers an offense for "and" in post-while condition + accepts "or" in post-while body + registers an offense for "or" in post-until condition + accepts || outside of conditional + accepts "and" in post-until body + accepts "and" in post-while body + accepts && outside of conditional + registers an offense for "and" in until condition + accepts "and" in while body + accepts "or" in if body + registers an offense for "and" in post-until condition + accepts "or" in until body + accepts "and" in if body + accepts "or" in while body + accepts "and" in until body + accepts "or" in post-until body + registers an offense for "and" in if condition + registers an offense for "or" in until condition + +RuboCop::Cop::Style::TrailingBodyOnModule + registers an offense when body trails after module definition + registers offense with multi-line module + autocorrects when there are multiple semicolons + autocorrects with comment after body + registers offense when module definition uses semicolon + accepts regular module + when module is not on first line of processed_source + autocorrects offense + +RuboCop::Cop::Layout::ClosingHeredocIndentation + does not register an offense for a << heredoc + accepts correctly indented closing heredoc when heredoc contents is after closing heredoc + accepts correctly indented closing heredoc when aligned at the beginning of method definition and using `strip_indent` + accepts correctly indented closing heredoc when aligned at the beginning of method definition and content is empty + does not register an offense for correctly indented empty heredocs + accepts correctly indented closing heredoc + accepts correctly indented closing heredoc when aligned at the beginning of method definition + accepts correctly indented closing heredoc when heredoc contents is before closing heredoc + registers an offense for bad indentation of a closing heredoc + accepts correctly indented closing heredoc when heredoc contents with blank line + registers an offense for incorrectly indented empty heredocs + +RuboCop::Cop::Style::Semicolon + registers an offense for range (`1...42`) with semicolon + registers an offense for several expressions + registers an offense for one line method with two statements + registers an offense for a semicolon at the beginning of a line + accepts one line method definitions + accepts semicolon before end if so configured + accepts one line empty class definitions + registers an offense for a single expression + registers an offense for range (`1..42`) with semicolon + registers an offense for semicolon at the end no matter what + accepts one line empty module definitions + accepts semicolon after params if so configured + accept semicolons inside strings + accepts one line empty method definitions + with a multi-expression line without a semicolon + does not register an offense + when AllowAsExpressionSeparator is true + accepts one line method with two statements + accepts several expressions + Ruby >= 2.6 + registers an offense for endless range with semicolon (irange only) + registers an offense for endless range with semicolon (irange and erange) + registers an offense for endless range with semicolon in the method definition + does not register an offense for endless range without semicolon + +RuboCop::Cop::Style::ConstantVisibility + registers an offense for module definitions + does not register an offense when passing a string to the visibility declaration + does not register an offense in the top level scope + when defining a constant in a module + does not register an offense when using a visibility declaration + registers an offense when not using a visibility declaration + when defining a constant in a class + with a multi-statement body + registers an offense when not using a visibility declaration + does not register an offense when using a visibility declaration + registers an offense when there is no matching visibility declaration + with a single-statement body + registers an offense when not using a visibility declaration + IgnoreModules + does not register an offense for class definitions + registers an offense for constants + +RuboCop::Cop::Style::StringMethods + registers an offense + when using safe navigation operator + registers an offense + +RuboCop::Cop::Style::RedundantSelfAssignment + registers an offense and corrects when assigning to attribute of non `self` + does not register an offense when assigning to attribute of `self` the result from other object + does not register an offense when there is no a receiver + registers an offense and corrects when assigning to attribute of `self` + does not register an offense when lhs and receiver are different + when lhs and receiver are the same + registers an offense and corrects when assigning to class variable + registers an offense and corrects when assigning to local variable + registers an offense and corrects when assigning to instance variable + registers an offense and corrects when assigning to global variable + +RuboCop::Cop::Style::DateTime + registers an offense when using DateTime for current time + does not register an offense when using Date for modern date + registers an offense when using ::DateTime for current time + does not register an offense when using Time for current time + registers an offense when using DateTime for modern date + does not register an offense when using ::DateTime for historic date + does not register an offense when using DateTime in another namespace + does not register an offense when using DateTime for historic date + when configured to not allow #to_datetime + registers an offense + when configured to allow #to_datetime + does not register an offense + +RuboCop::Cop::Style::KeywordParametersOrder + registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`s + registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`sand last argument is `blockarg` and argument parentheses omitted + does not register an offense when there are no `kwoptarg`s before `kwarg`s + registers an offense and corrects when `kwoptarg` is before `kwarg` and argument parentheses omitted + registers an offense and corrects when multiple `kwoptarg`s are interleaved with `kwarg`sand last argument is `kwrestarg` and argument parentheses omitted + registers an offense and corrects when `kwoptarg` is before `kwarg` + registers an offense and corrects when multiple `kwoptarg` are before `kwarg` and argument parentheses omitted + when using block keyword parameters + registers an offense and corrects when `kwoptarg` is before `kwarg` + does not register an offense when there are no `kwoptarg`s before `kwarg`s + +RuboCop::Cop::Style::MapCompactWithConditionalBlock + With single line block + registers an offense and corrects to `select` with modifier form of `if` condition + registers an offense and corrects to `select` with ternary expression + registers an offense and corrects to `reject` with ternary expression + registers an offense and corrects to `reject` with modifier form of `unless` condition + does not register offenses if `compact` is not chained to `map` + With multiline block + does not register offenses if return value is not same as block argument + registers an offense and corrects to `select` with guard clause of `if` and `next` has a value and return nil + does not register offenses if `compact` is not chained to `map` + registers an offense and corrects to `reject` with ternary expression + registers an offense and corrects to `select` with ternary expression + registers an offense and corrects to `select` with multi-line `if` condition + registers an offense and corrects to `reject` with guard clause of `unless` and `next` has a value and return nil + registers an offense and corrects to `reject` if `next value` in else_branch and `nil` in if_branch + registers an offense and corrects to `select` with guard clause of `if` and next explicitly nil + registers an offense and corrects to `reject` with guard clause of `unless` + registers an offense and corrects to `select` with `if` condition + registers an offense and corrects to `select` if `next value` in if_branch and `nil` in else_branch + registers an offense and corrects to `select` with guard clause of `if` + does not register offenses if there are multiple guard clauses + registers an offense and corrects to `select` if condition has not else branch + registers an offense and corrects to `select` with guard clause of `if` and `next` has a value + registers an offense and corrects to `reject` with `if` condition + does not register offenses if condition has elsif branch + registers an offense and corrects to `reject` with modifier form of `unless` condition + registers an offense and corrects to `select` with modifier form of `if` condition + registers an offense and corrects to `reject` with `unless` condition + registers an offense and corrects to `reject` with guard clause of `unless` and `next` explicitly nil + registers an offense and corrects to `reject` with guard clause of `unless` and `next` has a value + +RuboCop::Formatter::OffenseCountFormatter + #file_finished + when any offenses are detected + increments the count for the cop in offense_counts + when no offenses are detected + does not add to offense_counts + #finished + when there are many offenses + when --display-style-guide was given + shows links and sorts by offense count first and then by cop name + when --display-style-guide was not given + sorts by offense count first and then by cop name + when output tty is true + has a progress bar + #report_summary + when an offense is detected + shows the cop and the offense count + +RuboCop::Cop::Style::VariableInterpolation + registers an offense for interpolated global variables in regexp + registers an offense for interpolated regexp back references + registers an offense for interpolated global variables in backticks + registers an offense for interpolated regexp nth back references + registers an offense for interpolated class variables + registers an offense for interpolated instance variables + does not register an offense for variables in expressions + registers an offense for interpolated global variables in symbol + registers an offense for interpolated global variables in string + +RuboCop::Cop::Style::Strip + registers an offense for str.lstrip.rstrip + registers an offense for str.rstrip.lstrip + +RuboCop::Cop::Lint::UriRegexp + registers an offense and corrects using `::URI.regexp` with argument + registers an offense and corrects using `::URI.regexp` without argument + registers an offense and corrects using `URI.regexp` without argument + registers an offense and corrects using `URI.regexp` with argument + does not register an offense when using `regexp` with variable receiver + does not register an offense when using `regexp` without receiver + array argument + registers an offense and corrects using `URI.regexp` with %i arrays + registers an offense and corrects using `URI.regexp` with %w arrays + registers an offense and corrects using `URI.regexp` with literal arrays + +RuboCop::Cop::Style::MissingElse + EmptyElse enabled and set to warn on empty + given an if-statement + with a completely empty else-clause + doesn't register an offense + with no else-clause + registers an offense + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + >= Ruby 2.7 + does not register an offense + given a case statement + with no else-clause + registers an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + given an unless-statement + with an else-clause with side-effects + doesn't register an offense + with no else-clause + registers an offense + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + EmptyElse enabled and set to warn on nil + given an if-statement + with no else-clause + registers an offense + with an else-clause with side-effects + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + >= Ruby 2.7 + does not register an offense + given an unless-statement + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with no else-clause + registers an offense + given a case statement + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with no else-clause + registers an offense + with a completely empty else-clause + doesn't register an offense + UnlessElse enabled + >= Ruby 2.7 + does not register an offense + given an if-statement + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with no else-clause + registers an offense + given a case statement + with an else-clause containing only the literal nil + doesn't register an offense + with no else-clause + registers an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + given an unless-statement + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with no else-clause + doesn't register an offense + UnlessElse disabled + given a case statement + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with no else-clause + registers an offense + with an else-clause containing only the literal nil + doesn't register an offense + given an if-statement + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with no else-clause + registers an offense + >= Ruby 2.7 + does not register an offense + given an unless-statement + with a completely empty else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with no else-clause + registers an offense + configured to warn only on empty if + given a case statement + with a completely empty else-clause + doesn't register an offense + with no else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + given an unless-statement + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with no else-clause + registers an offense + given an if-statement + with no else-clause + registers an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + >= Ruby 2.7 + does not register an offense + configured to warn only on empty case + given a case statement + with no else-clause + registers an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + >= Ruby 2.7 + does not register an offense + given an if-statement + with an else-clause with side-effects + doesn't register an offense + with no else-clause + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + given an unless-statement + with no else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + +RuboCop::Cop::Layout::MultilineBlockLayout + registers an offense and corrects a do/end block with a mult-line body + registers an offense and corrects a line-break within arguments + does not register offenses when there is a newline for {} block + registers an offense and corrects for missing newline before opening parenthesis `(` for block body + does not register an offense for one-line {} blocks + registers an offense and corrects line-break before arguments + registers an offense and corrects for missing newline in do/end block with params + registers an offense and corrects for missing newline in {} block with params + registers an offense and corrects line-break before arguments with empty block + registers an offense and corrects a line break within destructured arguments + registers an offense for missing newline in do/end block w/o params + does not register offenses when there is a newline for do/end block + registers an offense and corrects for missing newline in {} block w/o params + doesn't move end keyword in a way which causes infinite loop in combination with Style/BlockEndNewLine + does not register an offense for one-line do/end blocks + registers offenses and corrects for lambdas + registers an offense and corrects line-break within arguments + registers offenses when there are not too many parameters to fit on one line + registers offenses and corrects for new lambda literal syntax + does not register offenses when there are too many parameters to fit on one line + considers the extra space required to join the lines together + autocorrects in more complex case with lambda and assignment, and aligns the next line two spaces out from the start of the block + does not error out when the block is empty + does not remove a trailing comma when only one argument is present + autocorrects nested parens correctly + Ruby 2.7 + registers an offense and corrects for missing newline in {} block w/o params + registers an offense and corrects for missing newline in do/end block with params + +RuboCop::Cop::Style::WordArray + with a WordRegex configuration which accepts almost anything + uses %w for strings which only appear to have an escape + uses %W when autocorrecting strings with non-printable chars + when EnforcedStyle is array + does not register an offense for arrays of single quoted strings + does not register an offense for arrays of strings with spaces + autocorrects a %w() array which uses single quotes + autocorrects multiline %w() array + does not register an offense for arrays of double quoted strings + registers an offense for an empty %w() array + doesn't fail with `encoding: binary + autocorrects a %W() array which uses escapes + registers an offense for a %w() array + does not register an offense for arrays of strings with hyphens + autocorrects a %w() array which uses string with hyphen + autocorrects a %W() array which uses string interpolation + doesn't fail on strings which are not valid UTF-8 + autocorrects a %W() array which uses string with hyphen + with a custom WordRegex configuration + registers an offense for arrays of email addresses + with a treacherous WordRegex configuration + doesn't break when words contain whitespace + doesn't break when words contain delimiters + when PreferredDelimiters is specified + autocorrects an array with delimiters + with non-default MinSize + does not autocorrect arrays of one symbol if MinSize > 1 + when EnforcedStyle is percent + does not register offense for array with allowed number of strings + keeps the line breaks in place after autocorrect + uses %W when autocorrecting strings with embedded newlines and tabs + registers an offense for a %w() array containing spaces + detects when the cop must be disabled to avoid offenses + does not register an offense for array starting with %w + registers an offense in a non-ambiguous block context + autocorrects an array of words in multiple lines + does not register an offense for array containing non-string + autocorrects an array of words and character constants + detects right value of MinSize to use for --auto-gen-config + registers an offense for strings with newline and tab escapes + does not register an offense for array with empty strings + autocorrects an array of words using partial newlines + autocorrects an array of words + does not register an offense on non-word strings + does not register an offense for array of non-words + registers an offense for arrays of strings containing hyphens + registers an offense for an array with comments outside of it + registers an offense for arrays with character constants + registers an offense for arrays of single quoted strings + corrects properly when there is an extra trailing comma + does not register an offense for a %w() array containing non word characters + autocorrects an array with one element + doesn't fail in wacky ways when multiple cop instances are used + does not register an offense for an array with comments in it + registers an offense for arrays of double quoted strings + when the default external encoding is UTF-8 + registers an offense for arrays of unicode word characters + when the default external encoding is US-ASCII + registers an offense for arrays of unicode word characters + when the WordRegex configuration is not a Regexp + still parses the code without raising an error + +RuboCop::Cop::Lint::RescueException + does not register an offense for rescue with no class + does not register an offense for rescue with other classes + does not crash when the splat operator is used in a rescue + does not register an offense for rescue with no class and => e + registers an offense for rescue with ::Exception + does not register an offense for rescue with other class + does not crash when the namespace of a rescued class is in a local variable + registers an offense for rescue with Exception => e + does not register an offense for rescue with a module prefix + registers an offense for rescue from Exception + registers an offense for rescue with StandardError, Exception + +RuboCop::Cop::Lint::MissingCopEnableDirective + when the maximum range size is infinite + does not register an offense when the disable department is re-enabled + does not register an offense when the disable cop is re-enabled + registers an offense when a cop is disabled and never re-enabled + registers an offense when a department is disabled and never re-enabled + when the cop is disabled in the config + reports no offense when re-disabling it until EOF + when the maximum range size is finite + does not register an offense when the disable cop is re-enabled within the limit + registers an offense when a cop is disabled for too many lines + does not register an offense when the disable department is re-enabled within the limit + registers an offense when a department is disabled and never re-enabled + registers an offense when a cop is disabled and never re-enabled + registers an offense when a department is disabled for too many lines + +RuboCop::Cop::Force + .force_name + returns the class name without namespace + #run_hook + invokes a hook in all cops + +RuboCop::Cop::Lint::RedundantDirGlobSort + does not register an offense when using `sort` without a receiver + does not register an offense when not using `sort` for `Dir` + when Ruby 3.0 or higher + does not register an offense when not using `sort` with `sort: false` option for `Dir` + does not register an offense when using `collection.sort` + registers an offense and correction when using `Dir[].sort.each do` + does not register an offense when using `Dir['./b/*.txt', './a/*.txt'].sort` + registers an offense and correction when using `Dir.glob.sort` + does not register an offense when using `Dir.glob('./b/*.txt', './a/*.txt').sort` + registers an offense and correction when using `Dir[].sort.each(&do_something)` + registers an offense and correction when using `::Dir.glob.sort` + does not register an offense when using `Dir[*path].sort` + does not register an offense when using `Dir.glob(*path).sort` + when Ruby 2.7 or lower + does not register an offense and correction when using `Dir.glob.sort` + does not register an offense and correction when using `Dir[].sort.each(&do_something)` + does not register an offense and correction when using `::Dir.glob.sort` + does not register an offense and correction when using `Dir[].sort.each do` + +RuboCop::Cop::Gemspec::RequiredRubyVersion + registers an offense when `required_ruby_version` is blank + registers an offense when `required_ruby_version` is an empty array + registers an offense when `required_ruby_version` is not specified + target ruby version > 2.7 + registers an offense when `required_ruby_version` is specified with ~> and is lower than `TargetRubyVersion` + recognizes Gem::Requirement and registers offense + recognizes a Gem::Requirement with multiple requirements and does not register an offense + registers an offense when `required_ruby_version` is specified in array and is lower than `TargetRubyVersion` + registers an offense when `required_ruby_version` is specified with >= and is lower than `TargetRubyVersion` + false negatives + does not register an offense when `required_ruby_version` is assigned as a variable (string literal) + does not register an offense when `required_ruby_version` is assigned as a variable (an array of string literal) + target ruby version > 2.6 + registers an offense when `required_ruby_version` is specified with ~> and is higher than `TargetRubyVersion` + registers an offense when `required_ruby_version` is specified with >= and is higher than `TargetRubyVersion` + target ruby version > 2.7 + does not register an offense when lowest version of `required_ruby_version` equals `TargetRubyVersion` + registers an offense when `required_ruby_version` is specified with ~> without a minor version and is lower than `TargetRubyVersion` + does not register an offense when `required_ruby_version` is specified with >= without a patch version and equals `TargetRubyVersion` + does not register an offense when `required_ruby_version` is specified with ~> without a patch version and equals `TargetRubyVersion` + registers an offense when `required_ruby_version` is specified with >= without a minor version and is lower than `TargetRubyVersion` + does not register an offense when `required_ruby_version` is specified with ~> and equals `TargetRubyVersion` + does not register an offense when `required_ruby_version` is specified with >= and equals `TargetRubyVersion` + +RuboCop::Cop::Lint::FloatComparison + does not register an offense when comparing with float using epsilon + registers an offense when comparing with method on float receiver + registers an offense when comparing with arightmetic operator on floats + registers an offense when comparing with float + does not register an offense when comparing with float method that can return numeric and returns integer + registers an offense when comparing with float method that can return numeric and returns float + registers an offense when comparing with float returning method + +RuboCop::Cop::Style::CombinableLoops + when for loop + registers an offense when looping over the same data as previous loop + does not register an offense when each branch contains the same single loop over the same collection + does not register an offense when the same loop method is used over different collections + does not register an offense when the same loops are interleaved with some code + when looping method + does not register an offense when the same loops are interleaved with some code + does not register an offense for when the same method with different arguments and safe navigation + registers an offense when looping over the same data as previous loop + does not register an offense when different loop methods are used over the same collection + does not register an offense when the same loop method is used over different collections + does not register an offense for when the same method with different arguments + does not register an offense when each branch contains the same single loop over the same collection + Ruby 2.7 + registers an offense when looping over the same data as previous loop in numblocks + +RuboCop::Cop::Style::ArrayCoercion + registers an offense and corrects when converting variable into array with check + registers an offense and corrects when splatting variable into array + does not register an offense when splat is not in array + does not register an offense when splatting multiple variables into array + does not register an offense when converting variable into other named array variable with check + +RuboCop::Cop::Style::StringConcatenation + correctly handles nested concatenable parts + does not register an offense when using `+` with all non string arguments + registers an offense and corrects for string concatenation + correctly handles strings with special characters + registers an offense and corrects for string concatenation as part of other expression + Mode = conservative + when first operand is not string literal + does not register offense + when first operand is string literal + registers offense + nested interpolation + registers an offense and corrects + inline block + registers an offense but does not correct + double quotes inside string + registers an offense and corrects with percentage quotes + registers an offense and corrects with double quotes + multiline + if condition + registers an offense but does not correct + string continuation + does not register an offense + simple expressions + registers an offense and corrects + multiline block + registers an offense but does not correct + heredoc + registers an offense but does not correct + registers an offense but does not correct when string concatenation with multiline heredoc text + double quotes inside string surrounded single quotes + registers an offense and corrects with double quotes + empty quotes + registers offense and corrects + +RuboCop::Cop::Style::DoubleCopDisableDirective + registers an offense for duplicate todo directives + does not register an offense for cops with single cop directive + registers an offense for duplicate disable directives + +RuboCop::Cop::InternalAffairs::LocationLineEqualityComparison + registers an offense and corrects when using `first_line` + registers an offense and corrects when using `loc.first_line` + registers and corrects an offense when comparing `#loc.line` with LHS and RHS + does not register an offense when using `same_line?` + registers an offense and corrects when using `source_range.first_line` + registers and corrects an offense when comparing `#loc.source_range` with LHS and RHS + +RuboCop::Cop::Lint::ElseLayout + accepts ternary ops + registers an offense and corrects for the entire else body being on the same line + accepts modifier forms + accepts empty braces + does not register an offense if the entire if is on a single line + registers an offense and corrects for expr on same line as else + accepts proper else + registers and corrects an offense when using multiple `elsif`s + registers an offense and corrects for elsifs + does not register an offense for an elsif with no body + +RuboCop::Cop::Layout::AssignmentIndentation + registers an offense for incorrectly indented rhs when multiple assignment + registers an offense for multi-lhs + registers an offense for incorrectly indented rhs + allows a properly indented rhs with fullwidth characters + allows assignments that do not start on a newline + registers an offense for incorrectly indented rhs whenmultiple assignment with line breaks on each line + ignores comparison operators + allows a properly indented rhs + when indentation width is overridden for this cop only + allows a properly indented rhs + autocorrects indentation + +RuboCop::Cop::Naming::MethodName + accepts for non-ascii characters + when configured for snake_case + registers an offense for mixed snake case and camel case + registers an offense for singleton upper case method without corresponding class + registers an offense for singleton camelCase method within class + registers an offense for mixed snake case and camel case in attr. + registers an offense for opposite + correct + accepts snake case in attr. + registers an offense for camel case in instance method name + accepts one line methods + accepts class emitter method in a module + accepts class emitter method in a module, even when it is defined inside another method + accepts snake case in names + registers an offense for capitalized camel case + registers an offense for camel case in singleton method name + registers an offense for mixed snake case and camel case in attr. + registers an offense for camel case methods names in attr. + accepts class emitter method in a class + accepts class emitter method in a class, even when it is defined inside another method + registers an offense for camel case method names in attr. + accepts unary operator definitions + registers an offense for capitalized camel case name in attr. + accepts operator definitions + when specifying `AllowedPatterns` + does not register an offense for snake case method name matching `AllowedPatterns` + does not register an offense for camel case method name in attr. + does not register an offense for snake case method name in attr. + does not register an offense for camel case method name matching `AllowedPatterns` + when configured for camelCase + accepts camel case in singleton method name + accepts unary operator definitions + registers an offense for capitalized camel case + registers an offense for singleton upper case method without corresponding class + accepts operator definitions + accepts camel case names in attr. + accepts one line methods + accepts camel case in instance method name + registers an offense for correct + opposite + registers an offense for singleton snake_case method within class + registers an offense for snake case name in attr. + accepts class emitter method in a module + registers an offense for mixed snake case and camel case + accepts class emitter method in a module, even when it is defined inside another method + accepts class emitter method in a class, even when it is defined inside another method + registers an offense for mixed snake case and camel case in attr. + accepts class emitter method in a class + registers an offense for mixed snake case and camel case in attr. + registers an offense for snake case in names + registers an offense for capitalized camel case name in attr. + registers an offense for camel case methods names in attr. + when specifying `AllowedPatterns` + does not register an offense for camel case method name in attr. + does not register an offense for snake case method name matching `AllowedPatterns` + does not register an offense for snake case method name in attr. + does not register an offense for camel case method name matching `AllowedPatterns` + +RuboCop::Formatter::FormatterSet + responds to all formatter API methods + #close_output_files + does not close non file output + closes all output files + add_formatter + adds a formatter with specified formatter type + adds a formatter to itself + can add multiple formatters by being invoked multiple times + when output path is omitted + adds a formatter outputs to $stdout + when output path is specified + adds a formatter outputs to the specified file + when parent directories don't exist + creates them + formatter API method + invokes the same method of all containing formatters + #builtin_formatter_class + returns class which matches single character alias name + returns class which matches double character alias name + returns class which matches passed alias name exactly + #custom_formatter_class + can handle namespaced constant name + can handle top level namespaced constant name + returns constant represented by the passed string + when non-existent constant name is passed + raises error + +RuboCop::Cop::Layout::SpaceBeforeBlockBraces + with invalid value for EnforcedStyleForEmptyBraces + fails with an error + when EnforcedStyle is no_space + accepts left brace without outer space + registers an offense and corrects braces surrounded by spaces + registers an offense and corrects correct + opposite style + with `EnforcedStyle` of `Style/BlockDelimiters` + accepts left brace without outer space + Ruby 2.7 + registers an offense and corrects correct + opposite style + with space before empty braces not allowed + registers an offense and corrects empty braces + accepts empty braces without outer space + with space before empty braces allowed + registers an offense and corrects empty braces + accepts empty braces with outer space + when EnforcedStyle is space + registers an offense and corrects multiline block where the left brace has no outer space + registers an offense and corrects opposite + correct style + registers an offense and corrects left brace without outer space + accepts braces surrounded by spaces + Ruby 2.7 + registers an offense and corrects opposite + correct style + registers an offense and corrects multiline block where the left brace has no outer space + +RuboCop::Cop::InternalAffairs::RedundantMessageArgument + does not register an offense when formatted `MSG` is passed + does not register an offense when `#message` with another node is passed + when `MSG` is passed + registers an offense + when `#message` is passed + registers an offense + when `#message` with offending node is passed + when there are others keyword arguments + registers an offense + when message is the only keyword argument + registers an offense + +RuboCop::Cop::Style::HashEachMethods + when node matches a keys#each or values#each + when receiver is a hash literal + registers offense, autocorrects {}#values.each to {}#each_value with a symbol proc argument + registers offense, autocorrects {}#keys.each with {}#each_key + registers offense, autocorrects {}#keys.each to {}#each_key with a symbol proc argument + does not register an offense for {}#each_value + does not register an offense for {}#each_key + registers offense, autocorrects {}#values.each with {}#each_value + when `AllowedReceivers: ['execute']` + registers an offense when receiver is not allowed name + does not register an offense when receiver is `execute` method + does not register an offense when receiver is `execute` method with a symbol proc argument + does not register an offense when receiver is `execute` variable + when receiver is a send + registers offense, autocorrects foo#keys.each to foo#each_key with a symbol proc argument + registers offense, autocorrects foo#values.each to foo#each_value + does not register an offense for Hash#each_value + does not register an offense for foo#each_key + registers offense, autocorrects foo#values.each to foo#each_value with a symbol proc argument + registers offense, autocorrects foo#keys.each to foo#each_key + Ruby 2.7 + registers offense, autocorrects foo#keys.each to foo#each_key with numblock + when receiver is implicit + does not register an offense for `keys.each` + does not register an offense for `values.each` with a symbol proc argument + does not register an offense for each_key + does not register an offense for each_value + does not register an offense for `keys.each` with a symbol proc argument + does not register an offense for `values.each` + +RuboCop::Cop::Lint::ErbNewArguments + >= Ruby 2.6 + registers an offense when using `ERB.new` with non-keyword 2nd and 3rd arguments + does not register an offense when using `ERB.new` with keyword arguments + registers an offense when using `ERB.new` with non-keyword 2nd and 3rd arguments andkeyword 4th argument + registers an offense when using `ERB.new` with non-keyword 2nd, 3rd and 4th arguments + registers an offense when using `ERB.new` with non-keyword 2nd argument + registers an offense when using `::ERB.new` with non-keyword 2nd, 3rd and 4th arguments + registers an offense when using `ERB.new` with non-keyword 2nd, 3rd and 4th arguments andkeyword 5th argument + does not register an offense when using `ERB.new` without optional arguments + when using `ActionView::Template::Handlers::ERB.new` + does not register an offense when using `ERB.new` without arguments + <= Ruby 2.5 + does not register an offense when using `ERB.new` with non-keyword arguments + +RuboCop::Cop::Security::Eval + accepts eval with a string that interpolates a literal + registers an offense for eval with string that has an interpolation + registers an offense for eval as function + accepts eval as variable + accepts eval as method + accepts eval with no arguments + registers an offense for eval as command + registers an offense `Binding#eval` + accepts eval on a literal string + accepts eval with a multiline string + with an explicit binding, filename, and line number + registers an offense for eval as command + registers an offense for eval as function + accepts eval on a literal string + +RuboCop::Cop::Style::MissingRespondToMissing + allows method_missing and respond_to_missing? when defined with inline access modifier and method_missing is not qualified by inline access modifier + allows method_missing and respond_to_missing? when defined with inline access modifier + registers an offense respond_to_missing? is implemented as a class method and method_missing is implemented as an instance method + allows method_missing and respond_to_missing? implemented as instance methods + registers an offense when method_missing is implemented as a class methods + registers an offense respond_to_missing? is implemented as an instance method and method_missing is implemented as a class method + allows method_missing and respond_to_missing? implemented as class methods + registers an offense when respond_to_missing? is not implemented + +RuboCop::Cop::Layout::FirstArgumentIndentation + when EnforcedStyle is consistent + when IndentationWidth:Width is 2 + accepts a first argument that is not preceded by a line break + registers an offense and corrects an under-indented first argument + does not view []= as an outer method call + registers an offense and corrects an over-indented first argument on a pipe method name + does not view chained call as an outer method call + accepts method calls with no arguments + registers an offense and corrects an over-indented first argument of `super` + registers an offense and corrects an over-indented first argument on a plus sign method name + registers an offense and corrects lines affected by another offense + registers an offense and corrects an over-indented first argument on an alphanumeric method name + accepts operator calls + registers an offense and corrects an over-indented first argument + when using safe navigation operator + registers an offense and corrects an under-indented 1st argument + for a setter call + accepts an unindented value + for assignment + accepts a correctly indented first argument and does not care about the second argument + with line break + registers an offense and corrects an under-indented first argument + accepts a correctly indented first argument + when the receiver contains a line break + accepts a correctly indented first argument + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument preceded by an empty line + when preceded by a comment line + registers an offense and corrects an under-indented first argument + accepts a correctly indented first argument + when IndentationWidth:Width is 4 + registers an offense and corrects an over-indented first argument + for method calls within method calls + registers an offense and corrects an over-indented first argument + accepts first argument indented relative to previous line + when indentation width is overridden for this cop only + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument + when EnforcedStyle is special_for_inner_method_call + when IndentationWidth:Width is 2 + does not view []= as an outer method call + registers an offense and corrects an over-indented first argument + accepts operator calls + does not view chained call as an outer method call + registers an offense and corrects an over-indented first argument on a plus sign method name + registers an offense and corrects an under-indented first argument + registers an offense and corrects an over-indented first argument of `super` + accepts a first argument that is not preceded by a line break + registers an offense and corrects an over-indented first argument on an alphanumeric method name + accepts method calls with no arguments + registers an offense and corrects lines affected by another offense + registers an offense and corrects an over-indented first argument on a pipe method name + for assignment + accepts a correctly indented first argument and does not care about the second argument + with line break + accepts a correctly indented first argument + registers an offense and corrects an under-indented first argument + when the receiver contains a line break + accepts a correctly indented first argument + accepts a correctly indented first argument preceded by an empty line + registers an offense and corrects an over-indented first argument + when preceded by a comment line + registers an offense and corrects an under-indented first argument + accepts a correctly indented first argument + for a setter call + accepts an unindented value + when using safe navigation operator + registers an offense and corrects an under-indented 1st argument + when indentation width is overridden for this cop only + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument + for method calls within method calls + with outer parentheses + registers an offense and corrects an over-indented first argument + without outer parentheses + accepts a first argument with special indentation + when IndentationWidth:Width is 4 + registers an offense and corrects an over-indented first argument + when EnforcedStyle is consistent_relative_to_receiver + for method calls within method calls + with outer parentheses + indents all relative to the receiver + registers an offense and corrects an over-indented 1st argument + without outer parentheses + accepts a first argument with special indentation + indents all relative to the receiver + when IndentationWidth:Width is 4 + registers an offense and corrects an over-indented first argument + when IndentationWidth:Width is 2 + does not view []= as an outer method call + does not register an offense when argument has expected indent width and the method is preceded by splat + does not view chained call as an outer method call + registers an offense and corrects an over-indented first argument + accepts a first argument that is not preceded by a line break + accepts operator calls + does not register an offense when argument has expected indent width and the method is preceded by double splat + registers an offense and corrects an under-indented first argument + registers an offense and corrects lines affected by other offenses + accepts method calls with no arguments + when the receiver contains a line break + accepts a correctly indented first argument preceded by an empty line + registers an offense and corrects an over-indented 1st argument + accepts a correctly indented first argument + when preceded by a comment line + accepts a correctly indented first argument + registers an offense and corrects an under-indented first argument + for assignment + register an offense and corrects a correctly indented first argument and does not care about the second argument + with line break + accepts a correctly indented first argument + registers an offense and corrects an under-indented first argument + when indentation width is overridden for this cop only + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument + when EnforcedStyle is special_for_inner_method_call_in_parentheses + when IndentationWidth:Width is 4 + registers an offense and corrects an over-indented first argument + for method calls within method calls + without outer parentheses + accepts a first argument with consistent style indentation + with outer parentheses + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument in interpolation + registers an offense and corrects an under-indented first argument + accepts a correctly indented first argument with fullwidth characters + when indentation width is overridden for this cop only + registers an offense and corrects an over-indented first argument + accepts a correctly indented first argument + when IndentationWidth:Width is 2 + registers an offense and corrects lines affected by another offense + registers an offense and corrects an over-indented first argument + accepts a first argument that is not preceded by a line break + accepts method calls with no arguments + registers an offense and corrects an over-indented first argument on a plus sign method name + registers an offense and corrects an over-indented first argument on a pipe method name + registers an offense and corrects an over-indented first argument on an alphanumeric method name + registers an offense and corrects an under-indented first argument + does not view []= as an outer method call + accepts operator calls + does not view chained call as an outer method call + registers an offense and corrects an over-indented first argument of `super` + when using safe navigation operator + registers an offense and corrects an under-indented 1st argument + for a setter call + accepts an unindented value + for assignment + accepts a correctly indented first argument and does not care about the second argument + with line break + accepts a correctly indented first argument + registers an offense and corrects an under-indented first argument + when the receiver contains a line break + accepts a correctly indented first argument preceded by an empty line + accepts a correctly indented first argument + registers an offense and corrects an over-indented first argument + when preceded by a comment line + registers an offense and corrects an under-indented first argument + accepts a correctly indented first argument + +RuboCop::Cop::Naming::InclusiveLanguage + suggestions + flagged term with one suggestion + includes the suggestion in the offense message + flagged term with two suggestions + includes both suggestions in the offense message + flagged term with three or more suggestions + includes all suggestions in the message + variables + when CheckVariables config is true + registers offenses for class variables + registers offenses for instance variables + registers offenses for global variables + when CheckVariables config is false + does not register offenses for variables + constants + when CheckConstants config is true + registers offenses for constants + when CheckConstants config is false + does not register offenses for constants + comments + registers an offense in a single line comment + registers an offense in a block comment + when CheckComments is false + does not register an offense + flagged term matching + registers an offense for a partial word match + registers an offense when using a flagged term with mixed case + registers an offense when using a flagged term + WholeWord: true + only flags when the term is a whole word + disable default flagged term + ignores flagged terms that are set to nil + regex + registers an offense for a flagged term matched with a regexp + multiple offenses on a line + registers an offense for each word + symbols + when CheckSymbols is true + registers an offense + when CheckSymbols is false + does not register an offense + identifiers + when CheckIdentifiers config is true + registers an offense + when CheckIdentifiers config is false + does not register offenses for identifiers + strings + does not register offenses and not raise `ArgumentError` for invalid byte sequence in UTF-8 + registers an offense in a heredoc + registers an offense for an interpolated string + registers an offense for a multiline string + when CheckStrings config is false + does not register offenses for strings + allowed use + does not register an offense for an allowed use + offense after an allowed use + registers an offense at the correct location + filepath + multiple offenses in filename + registers an offense with all problematic words + offense in directory name + registers an offense for a director + one offense in filename + registers an offense + CheckFilepaths is false + does not register an offense + +RuboCop::Cop::Lint::FloatOutOfRange + does not register an offense for respectably sized floats + does not register an offense for 0.0 + does not register an offense for tiny little itty bitty floats + on floats so close to zero that nobody can tell the difference + registers an offense + on whopping big floats which tip the scales + registers an offense + +RuboCop::Cop::Naming::HeredocDelimiterCase + when enforced style is uppercase + with a non-interpolated heredoc + when using double quoted delimiters + does not register an offense with an uppercase delimiter + registers an offense and corrects with a lowercase delimiter + registers an offense and corrects with a camel case delimiter + when using single quoted delimiters + registers an offense and corrects with a camel case delimiter + registers an offense and corrects with a lowercase delimiter + does not register an offense with an uppercase delimiter + when using back tick delimiters + does not register an offense with an uppercase delimiter + registers an offense and corrects with a lowercase delimiter + registers an offense and corrects with a camel case delimiter + when using non-word delimiters + does not register an offense + with an interpolated heredoc + registers an offense with a camel case delimiter + does not register an offense with an uppercase delimiter + registers an offense and corrects with a lowercase delimiter + with a squiggly heredoc + registers an offense and corrects with a lowercase delimiter + does not register an offense with an uppercase delimiter + registers an offense and corrects with a camel case delimiter + when enforced style is lowercase + with an interpolated heredoc + registers an offense and corrects with an uppercase delimiter + does not register an offense with a lowercase delimiter + registers an offense and corrects with a camel case delimiter + with a non-interpolated heredoc + registers an offense and corrects with a camel case delimiter + registers an offense and corrects with an uppercase delimiter + does not register an offense with a lowercase delimiter + with a squiggly heredoc + does not register an offense with a lowercase delimiter + registers an offense and corrects with a camel case delimiter + registers an offense and corrects with an uppercase delimiter + +RuboCop::Cop::AlignmentCorrector + #correct + with single-line here docs + does not indent body and end marker + simple indentation + with a negative column delta + outdents + with a positive column delta + indents + with large column deltas + with heredoc in backticks (<<``) + behaves like heredoc indenter + does not change indentation of here doc bodies and end markers + with plain heredoc (<<) + behaves like heredoc indenter + does not change indentation of here doc bodies and end markers + within string literals + does not insert whitespace + +RuboCop::Cop::Style::ObjectThen + EnforcedStyle: then + registers an offense for yield_self with proc param + accepts yield_self with more than 1 param + accepts yield_self without a block + Ruby 2.7 + registers an offense for yield_self with block + Ruby 2.5 + accepts yield_self with block + Ruby 2.6 + registers an offense for yield_self with block + EnforcedStyle: yield_self + accepts then with more than 1 param + registers an offense for then with block + accepts then without a block + registers an offense for then with proc param + +RuboCop::Cop::Style::EmptyElse + configured to warn on empty else and nil in else + given a case statement + with an else-clause with side-effects + doesn't register an offense + with no else-clause + doesn't register an offense + with an else-clause containing only the literal nil + behaves like autocorrect + MissingElse is case + does not autocorrect + MissingElse is both + does not autocorrect + MissingElse is if + does autocorrection + MissingElse is disabled + does autocorrection + with a completely empty else-clause + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is disabled + does autocorrection + MissingElse is case + does not autocorrect + MissingElse is if + does autocorrection + given an if-statement + with a completely empty else-clause + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is disabled + does autocorrection + MissingElse is if + does not autocorrect + with an else-clause containing only the literal nil + with one elsif + behaves like autocorrect + MissingElse is case + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is if + does not autocorrect + MissingElse is disabled + does autocorrection + with multiple elsifs + behaves like autocorrect + MissingElse is if + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is disabled + does autocorrection + with no else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + given an unless-statement + with no else-clause + doesn't register an offense + with an else-clause containing only the literal nil + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is disabled + does autocorrection + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is if + does not autocorrect + when `AllowComments: true` + given an unless-statement + with comment and nil else-clause + doesn't register an offense + with comment and empty else-clause + doesn't register an offense + with not comment and empty else-clause + registers an offense + with not comment and nil else-clause + registers an offense + given a case statement + with not comment and nil else-clause + registers an offense + with comment and nil else-clause + doesn't register an offense + with not comment and empty else-clause + registers an offense + with comment and empty else-clause + doesn't register an offense + given an if-statement + with not comment and nil else-clause + registers an offense + with comment and nil else-clause + doesn't register an offense + with comment and empty else-clause + doesn't register an offense + with not comment and empty else-clause + registers an offense + with nested if and case statement + behaves like autocorrect + MissingElse is case + does not autocorrect + MissingElse is if + does autocorrection + MissingElse is disabled + does autocorrection + MissingElse is both + does not autocorrect + configured to warn on nil in else + given a case statement + with an else-clause containing only the literal nil + when the result is assigned to a variable + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is if + does autocorrection + MissingElse is case + does not autocorrect + using semicolons + behaves like autocorrect + MissingElse is if + does autocorrection + MissingElse is case + does not autocorrect + MissingElse is both + does not autocorrect + MissingElse is disabled + does autocorrection + with no else-clause + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + given an if-statement + with an else-clause containing only the literal nil using semicolons + with one elsif + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is case + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is both + does not autocorrect + with multiple elsifs + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is both + does not autocorrect + with an else-clause containing only the literal nil + when standalone + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is disabled + does autocorrection + when the result is assigned to a variable + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is if + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is disabled + does autocorrection + with no else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + doesn't register an offense + given an unless-statement + with a completely empty else-clause + doesn't register an offense + with an else-clause containing only the literal nil + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is disabled + does autocorrection + MissingElse is if + does not autocorrect + with no else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + configured to warn on empty else + given a case statement + with an else-clause containing only the literal nil + doesn't register an offense + with no else-clause + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + behaves like autocorrect + MissingElse is if + does autocorrection + MissingElse is disabled + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is case + does not autocorrect + given an unless-statement + with an else-clause containing only the literal nil + doesn't register an offense + with an else-clause with side-effects + doesn't register an offense + with a completely empty else-clause + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is both + does not autocorrect + with no else-clause + doesn't register an offense + given an if-statement + with an else-clause containing only the literal nil + doesn't register an offense + with a completely empty else-clause + not using semicolons + behaves like autocorrect + MissingElse is both + does not autocorrect + MissingElse is if + does not autocorrect + MissingElse is case + does autocorrection + MissingElse is disabled + does autocorrection + using semicolons + behaves like autocorrect + MissingElse is disabled + does autocorrection + MissingElse is case + does autocorrection + MissingElse is both + does not autocorrect + MissingElse is if + does not autocorrect + with an else-clause with side-effects + doesn't register an offense + in an if-statement + behaves like autocorrect + MissingElse is case + does autocorrection + MissingElse is if + does not autocorrect + MissingElse is disabled + does autocorrection + MissingElse is both + does not autocorrect + with an empty comment + does not autocorrect + with no else-clause + doesn't register an offense + +RuboCop::Cop::Style::ExpandPathArguments + registers an offense when using `File.expand_path('./../..', __FILE__)` + does not register an offense when using `File.expand_path(__FILE__)` + registers an offense when using `File.expand_path('../../..', __FILE__)` + does not register an offense when using `File.expand_path('..', __dir__)` + registers an offense when using `Pathname.new(__FILE__).parent.expand_path` + does not register an offense when using `File.expand_path(__dir__)` + registers an offense when using `::File.expand_path('./../..', __FILE__)` + does not register an offense when using `File.expand_path(path, __FILE__)` + registers an offense when using `File.expand_path('.', __FILE__)` + registers an offense when using `File.expand_path('..', __FILE__)` + does not register an offense when using `Pathname(__dir__).expand_path` + registers an offense when using `File.expand_path('../../lib', __FILE__)` + registers an offense when using `File.expand_path('../..', __FILE__)` + registers an offense when using `::Pathname.new(__FILE__).parent.expand_path` + does not register an offense when using `File.expand_path("#{path_to_file}.png", __FILE__)` + registers an offense when using `Pathname(__FILE__).parent.expand_path` + +RuboCop::Cop::Layout::SpaceAfterSemicolon + does not crash if semicolon is the last character of the file + registers an offense and corrects semicolon without space after it + inside block braces + when EnforcedStyle for SpaceInsideBlockBraces is no_space + accepts no space between a semicolon and a closing brace + behaves like common behavior + accepts a space between a semicolon and a closing brace + when EnforcedStyle for SpaceInsideBlockBraces is space + registers an offense and corrects no space between a semicolon and a closing brace + behaves like common behavior + accepts a space between a semicolon and a closing brace + +RuboCop::Cop::Lint::UselessMethodDefinition + registers an offense and corrects for method containing only `super` call + does not register an offense for constructor with only comments + does not register an offense for empty constructor + does not register an offense when method definition contains optional argument + does not register an offense for constructor containing additional code to `super` + does not register an offense for empty class level `initialize` method + does not register an offense when `super` arguments differ from method arguments + does not register an offense when non-constructor contains only comments + does not register an offense for method containing additional code to `super` + does not register an offense when method definition contains optional keyword argument + +RuboCop::ConfigStore + .for + always uses config specified in command line + when no config specified in command line + gets config path and config from cache if available + searches for config path if not available in cache + when --force-default-config option is specified + uses default config without searching for config path + +RuboCop::Cop::Style::RedundantAssignment + accepts empty method body + accepts empty when nodes + reports an offense for def ending with assignment and returning + accepts empty if body + does not register an offense when ensure block present + when rescue blocks present + registers an offense and autocorrects when inside function or rescue block + when inside begin-end body + registers an offense and autocorrects + when inside an if-branch + registers an offense and autocorrects + when inside a when-branch + registers an offense and autocorrects + +RuboCop::Cop::Style::ConditionalAssignment + IncludeTernaryExpressions false + allows assigning any variable type to ternary + SingleLineConditionsOnly true + corrects assignment when without `else` branch + corrects assignment to a namespaced constant + registers an offense for assignment using a method that ends with an equal sign + registers an offense for assignment using []= + registers an offense for assignment to case when then else + registers an offense for assignment to an if then else + allows a method call in the subject of a ternary operator + behaves like all assignment types + registers an offense any assignment to case when + allows any assignment to if without else + registers an offense for any assignment to unless else + registers an offense any assignment to if else + does not crash when used inside rescue + registers an offense for any assignment to ternary + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + registers an offense any assignment to if else + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense any assignment to case when + allows any assignment to if without else + registers an offense for any assignment to unless else + behaves like multiline all assignment types allow + any assignment to a multiline unless else + any assignment to a multiline if else + any assignment to a multiline case when + behaves like all assignment types + registers an offense any assignment to case when + registers an offense for any assignment to unless else + registers an offense any assignment to if else + does not crash when used inside rescue + allows any assignment to if without else + registers an offense for any assignment to ternary + behaves like multiline all variable types allow + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline case when + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + behaves like all assignment types + registers an offense for any assignment to ternary + allows any assignment to if without else + registers an offense any assignment to if else + registers an offense for any assignment to unless else + registers an offense any assignment to case when + does not crash when used inside rescue + behaves like all variable types + allows assignment to if without else + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to ternary + does not crash for rescue assignment + registers an offense assigning any variable type to if elsif else + registers an offense for assigning any variable type to case when + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + allows any assignment to if without else + registers an offense any assignment to case when + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to if else + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline unless else + any assignment to a multiline if else + behaves like all variable types + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to if elsewith multiple assignment + does not crash for rescue assignment + registers an offense assigning any variable type to ternary + allows assignment to if without else + registers an offense assigning any variable type to if elsif else + registers an offense for assigning any variable type to case when + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense for any assignment to unless else + registers an offense any assignment to case when + allows any assignment to if without else + registers an offense any assignment to if else + registers an offense for any assignment to ternary + does not crash when used inside rescue + behaves like multiline all variable types allow + assigning any variable type to a multiline unless else + assigning any variable type to a multiline case when + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline if else + assigning any variable type to a multiline if elsif else + behaves like multiline all variable types allow + assigning any variable type to a multiline if else + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline case when + behaves like single line condition autocorrect + corrects assignment to an if else condition + corrects assignment to an if elsif else condition + corrects assignment to a case when else condition + corrects assignment to a ternary operator + corrects assignment to a case when else with multiple whens + corrects assignment to an unless else condition + corrects assignment to an if elsif else with multiple elsifs + behaves like all assignment types + allows any assignment to if without else + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to case when + registers an offense any assignment to if else + does not crash when used inside rescue + behaves like all assignment types + registers an offense any assignment to case when + registers an offense any assignment to if else + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense for any assignment to unless else + allows any assignment to if without else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + registers an offense for any assignment to ternary + registers an offense any assignment to if else + does not crash when used inside rescue + allows any assignment to if without else + registers an offense any assignment to case when + registers an offense for any assignment to unless else + behaves like all variable types + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to ternary + allows assignment to if without else + registers an offense assigning any variable type to unless else + does not crash for rescue assignment + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to if elsif else + registers an offense for assigning any variable type to case when + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like multiline all variable types allow + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline case when + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline if else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline unless else + any assignment to a multiline case when + behaves like all assignment types + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to case when + allows any assignment to if without else + registers an offense any assignment to if else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like multiline all variable types allow + assigning any variable type to a multiline case when + assigning any variable type to a multiline if elsif else + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + behaves like all assignment types + does not crash when used inside rescue + registers an offense any assignment to case when + registers an offense for any assignment to unless else + allows any assignment to if without else + registers an offense any assignment to if else + registers an offense for any assignment to ternary + behaves like all assignment types + registers an offense for any assignment to unless else + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense any assignment to case when + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like all assignment types + allows any assignment to if without else + registers an offense any assignment to case when + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to if else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + registers an offense for any assignment to unless else + does not crash when used inside rescue + registers an offense any assignment to case when + registers an offense for any assignment to ternary + registers an offense any assignment to if else + allows any assignment to if without else + behaves like multiline all assignment types allow + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like all assignment types + registers an offense any assignment to if else + registers an offense for any assignment to unless else + registers an offense for any assignment to ternary + does not crash when used inside rescue + allows any assignment to if without else + registers an offense any assignment to case when + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + allows any assignment to if without else + registers an offense any assignment to case when + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to if else + behaves like all assignment types + does not crash when used inside rescue + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense any assignment to case when + registers an offense for any assignment to unless else + registers an offense for any assignment to ternary + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like all variable types + registers an offense assigning any variable type to ternary + does not crash for rescue assignment + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to if elsewith multiple assignment + allows assignment to if without else + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to if elsif else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline unless else + any assignment to a multiline if else + for loop + ignores pseudo assignments in a for loop + behaves like all assignment types + registers an offense for any assignment to unless else + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense any assignment to if else + registers an offense any assignment to case when + allows any assignment to if without else + behaves like all variable types + registers an offense assigning any variable type to if elsif else + registers an offense assigning any variable type to if elsewith multiple assignment + allows assignment to if without else + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if else + registers an offense for assigning any variable type to case when + does not crash for rescue assignment + registers an offense assigning any variable type to unless else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + does not crash when used inside rescue + registers an offense for any assignment to unless else + allows any assignment to if without else + registers an offense any assignment to if else + registers an offense any assignment to case when + registers an offense for any assignment to ternary + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like all variable types + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to if else + allows assignment to if without else + registers an offense assigning any variable type to unless else + registers an offense for assigning any variable type to case when + does not crash for rescue assignment + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if elsif else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all variable types + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to if elsif else + registers an offense assigning any variable type to ternary + does not crash for rescue assignment + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to if else + allows assignment to if without else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline unless else + any assignment to a multiline case when + behaves like multiline all assignment types allow + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all assignment types allow + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like multiline all variable types allow + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline if else + assigning any variable type to a multiline case when + assigning any variable type to a multiline unless else + behaves like multiline all assignment types allow + any assignment to a multiline case when + any assignment to a multiline unless else + any assignment to a multiline if else + behaves like multiline all variable types allow + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + assigning any variable type to a multiline case when + assigning any variable type to an if else with multiline in one branch + SingleLineConditionsOnly false + corrects assignment to a case when else with multiple whens + corrects assignment to an if elsif else with multiple elsifs + corrects assignment to a multiline if elsif else condition + corrects assignment to an unless else condition + corrects assignment to a multiline if else condition + corrects assignment to a case when else condition + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline if else + any assignment to a multiline case when + behaves like all assignment types + registers an offense any assignment to if else + registers an offense for any assignment to unless else + registers an offense any assignment to case when + does not crash when used inside rescue + allows any assignment to if without else + registers an offense for any assignment to ternary + behaves like all assignment types + registers an offense any assignment to case when + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense any assignment to if else + registers an offense for any assignment to unless else + allows any assignment to if without else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like multiline all variable types offense + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline if else + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline case when + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + allows any assignment to if without else + does not crash when used inside rescue + registers an offense any assignment to if else + registers an offense for any assignment to unless else + registers an offense for any assignment to ternary + registers an offense any assignment to case when + behaves like all assignment types + registers an offense any assignment to case when + registers an offense for any assignment to ternary + registers an offense any assignment to if else + registers an offense for any assignment to unless else + allows any assignment to if without else + does not crash when used inside rescue + behaves like multiline all variable types offense + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline unless else + assigning any variable type to a multiline case when + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline if else + behaves like multiline all variable types offense + assigning any variable type to a multiline case when + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + assigning any variable type to a multiline if elsif else + behaves like all assignment types + allows any assignment to if without else + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense for any assignment to unless else + registers an offense any assignment to if else + registers an offense any assignment to case when + behaves like multiline all assignment types offense + any assignment to a multiline case when + any assignment to a multiline unless else + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline case when + any assignment to a multiline unless else + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like single line condition autocorrect + corrects assignment to an if else condition + corrects assignment to a case when else with multiple whens + corrects assignment to an if elsif else condition + corrects assignment to a case when else condition + corrects assignment to an if elsif else with multiple elsifs + corrects assignment to an unless else condition + corrects assignment to a ternary operator + behaves like all assignment types + allows any assignment to if without else + registers an offense any assignment to case when + registers an offense for any assignment to unless else + does not crash when used inside rescue + registers an offense for any assignment to ternary + registers an offense any assignment to if else + behaves like all assignment types + does not crash when used inside rescue + allows any assignment to if without else + registers an offense any assignment to case when + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to if else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline unless else + any assignment to a multiline case when + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + does not crash when used inside rescue + registers an offense any assignment to if else + registers an offense for any assignment to ternary + registers an offense for any assignment to unless else + registers an offense any assignment to case when + allows any assignment to if without else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline if else + any assignment to a multiline case when + behaves like all variable types + does not crash for rescue assignment + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to if elsif else + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if elsewith multiple assignment + allows assignment to if without else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense for any assignment to ternary + allows any assignment to if without else + does not crash when used inside rescue + registers an offense for any assignment to unless else + registers an offense any assignment to case when + registers an offense any assignment to if else + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline if else + any assignment to a multiline case when + behaves like all assignment types + registers an offense for any assignment to ternary + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense for any assignment to unless else + registers an offense any assignment to case when + does not crash when used inside rescue + behaves like all variable types + does not crash for rescue assignment + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to if elsif else + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to unless else + allows assignment to if without else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense for any assignment to unless else + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense any assignment to case when + behaves like all variable types + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to if elsif else + registers an offense assigning any variable type to if else + allows assignment to if without else + does not crash for rescue assignment + registers an offense assigning any variable type to unless else + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to ternary + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like multiline all variable types offense + assigning any variable type to a multiline unless else + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline case when + assigning any variable type to a multiline if else + assigning any variable type to a multiline if elsif else + behaves like all assignment types + registers an offense for any assignment to unless else + allows any assignment to if without else + registers an offense any assignment to case when + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense any assignment to if else + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline case when + any assignment to a multiline unless else + behaves like all assignment types + registers an offense for any assignment to unless else + registers an offense any assignment to if else + registers an offense for any assignment to ternary + registers an offense any assignment to case when + does not crash when used inside rescue + allows any assignment to if without else + behaves like all variable types + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if else + does not crash for rescue assignment + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to if elsif else + registers an offense for assigning any variable type to case when + allows assignment to if without else + registers an offense assigning any variable type to if elsewith multiple assignment + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense any assignment to if else + registers an offense for any assignment to unless else + registers an offense any assignment to case when + allows any assignment to if without else + registers an offense for any assignment to ternary + does not crash when used inside rescue + behaves like multiline all assignment types offense + any assignment to a multiline unless else + any assignment to a multiline case when + any assignment to a multiline if else + behaves like multiline all variable types offense + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline case when + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + behaves like all assignment types + registers an offense any assignment to case when + registers an offense for any assignment to unless else + does not crash when used inside rescue + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense for any assignment to ternary + behaves like all variable types + registers an offense assigning any variable type to if elsif else + allows assignment to if without else + registers an offense for assigning any variable type to case when + does not crash for rescue assignment + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to if else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like multiline all variable types offense + assigning any variable type to a multiline case when + assigning any variable type to a multiline if elsif else + assigning any variable type to a multiline unless else + assigning any variable type to a multiline if else + assigning any variable type to an if else with multiline in one branch + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline unless else + any assignment to a multiline case when + behaves like all variable types + registers an offense assigning any variable type to ternary + registers an offense assigning any variable type to if else + registers an offense assigning any variable type to unless else + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to if elsif else + allows assignment to if without else + does not crash for rescue assignment + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense for any assignment to unless else + registers an offense for any assignment to ternary + registers an offense any assignment to if else + does not crash when used inside rescue + registers an offense any assignment to case when + allows any assignment to if without else + behaves like multiline all assignment types offense + any assignment to a multiline if else + any assignment to a multiline unless else + any assignment to a multiline case when + behaves like multiline all assignment types offense + any assignment to a multiline case when + any assignment to a multiline if else + any assignment to a multiline unless else + behaves like all variable types + registers an offense assigning any variable type to unless else + allows assignment to if without else + registers an offense assigning any variable type to if elsif else + does not crash for rescue assignment + registers an offense assigning any variable type to if elsewith multiple assignment + registers an offense assigning any variable type to ternary + registers an offense for assigning any variable type to case when + registers an offense assigning any variable type to if else + >= Ruby 2.7 + registers an offense for assigning any variable type to case in + behaves like all assignment types + registers an offense any assignment to if else + allows any assignment to if without else + registers an offense for any assignment to ternary + does not crash when used inside rescue + registers an offense for any assignment to unless else + registers an offense any assignment to case when + behaves like all assignment types + registers an offense for any assignment to unless else + does not crash when used inside rescue + allows any assignment to if without else + registers an offense for any assignment to ternary + registers an offense any assignment to if else + registers an offense any assignment to case when + behaves like multiline all variable types offense + assigning any variable type to a multiline if elsif else + assigning any variable type to an if else with multiline in one branch + assigning any variable type to a multiline unless else + assigning any variable type to a multiline case when + assigning any variable type to a multiline if else + behaves like all assignment types + allows any assignment to if without else + registers an offense for any assignment to unless else + registers an offense any assignment to if else + registers an offense any assignment to case when + does not crash when used inside rescue + registers an offense for any assignment to ternary + +RuboCop::Cop::Style::HashAsLastArrayItem + when EnforcedStyle is braces + does not register an offense when the hash is empty + does not register an offense when hash with braces + does not register an offense when hash is not inside array + registers an offense and corrects when hash without braces + does not register an offense when the array is all hashes + does not register an offense when using double splat operator + when EnforcedStyle is no_braces + registers an offense and corrects when hash with braces and trailing comma and new line + does not register an offense when passing an implicit array to a setter + does not register an offense when the array is all hashes + does not register an offense when hash without braces + does not register an offense when the hash is empty + does not register an offense when hash is not the last element + does not register an offense when hash is not inside array + registers an offense and corrects when hash with braces and trailing comma + registers an offense and corrects when hash with braces + +RuboCop::Cop::Lint::InterpolationCheck + registers an offense and corrects when including interpolation and double quoted string in single quoted string + does not register an offense for escaped crab claws in dstr + does not register offense for strings in %w() + does not register an offense for properly interpolation strings + does not crash for \xff + registers an offense for interpolation in single quoted split string + registers an offense and corrects for interpolation in single quoted string + registers an offense for interpolation in double + single quoted split string + does not register an offense for an escaped interpolation + does not register an offense for interpolation in nested strings + does not register an offense for interpolation in a regexp + +RuboCop::Cop::Lint::BigDecimalNew + registers an offense and corrects using `BigDecimal.new()` + does not register an offense when using `BigDecimal()` + registers an offense and corrects using `::BigDecimal.new()` + +RuboCop::Cop::Style::ImplicitRuntimeError + registers an offense for `raise` without error class + does not register an offense for `fail` without arguments + does not register an offense for `raise` without arguments + does not register an offense for `raise` with an error class + registers an offense for `fail` with a multiline string + does not register an offense for `fail` with an error class + registers an offense for `raise` with a multiline string + registers an offense for `fail` without error class + +RuboCop::Cop::Lint::UselessAssignment + when a method argument is reassigned but not passed to super + registers an offense + when a referenced variable is reassigned but not re-referenced + registers an offense for the non-re-referenced assignment + when a variable is assigned in loop body and referenced in post while condition + accepts + when a named capture is referenced + accepts + when a named capture is unreferenced in other than top level + registers an offense + when a variable that has same name as outer scope variable is not referenced in a method defined in loop + registers an offense + when an optional method argument is not used + accepts + when a variable is assigned and unreferenced in a class subclassing another class stored in local variable + registers an offense + when a variable is assigned and unreferenced in a singleton class + registers an offense + when a block argument is not used + accepts + when a variable is reassigned in single branch if and referenced after the branching + accepts + when a referenced variable is reassigned but not re-referenced in a method defined in loop + registers an offense + when a variable is assigned with multiple assignment and unreferenced + registers an offense + when a variable is assigned with ||= at the last expression of the scope + registers an offense + when a variable is reassigned multiple times in rescue and referenced after the begin + registers an offense + when a variable is assigned and passed to a method followed by method taking block + accepts + when a variable is reassigned multiple times in main body of begin then referenced after the begin + accepts + when there is only one AST node and it is unused variable + registers an offense + inside a `case-match` node + does not register an offense when the variable is used + when a variable is assigned in begin and referenced outside + accepts + when a variable is assigned and unreferenced in a singleton method defined with self keyword + registers an offense + when a variable is assigned while being passed to a method taking block + and the variable is used + accepts + and the variable is not used + registers an offense + when a variable is assigned first with ||= and referenced + accepts + when a variable is assigned in branch of modifier if that references the variable in its conditional clauseand referenced after the branching + accepts + when a variable is assigned in 2 identical if branches + doesn't think 1 of the 2 assignments is useless + when a variable is assigned in each branch of if and referenced in the else branch + registers an offense for the assignment in the if branch + when a unreferenced variable is reassigned on the left side of && and referenced after the && + registers an offense for the unreferenced assignment + when a variable is reassigned multiple times in ensure with rescue then referenced after the begin + registers an offense + when a method argument is not used + accepts + when a variable is assigned in branch of modifier if that references the variable in its conditional clauseand unreferenced + registers an offense + when a block local variable is assigned and unreferenced + registers offenses for the assignment + when a variable is assigned in main body of begin, rescue and else then referenced after the begin + accepts + when a variable is assigned multiple times but unreferenced + registers offenses for each assignment + when a variable is assigned and unreferenced in a class + registers an offense + when a variable is referenced in rhs of named capture expression + accepts + when a unreferenced variable is reassigned on the right side of && and referenced after the && + accepts + when a variable is reassigned at the end of loop body and would be referenced in next iteration + accepts + when a local variable is unreferenced and zero arity super is called + registers an offense + when a variable is assigned in single branch if and unreferenced + registers an offense + when a variable is reassigned at the end of loop body and would be referenced in loop condition + accepts + when a unreferenced variable is reassigned in same branch and referenced after the branching + registers an offense for the unreferenced assignment + when a variable is assigned and unreferenced in top level + registers an offense + when an assignment in a if branch is referenced in another if branch + accepts + when a variable is assigned in main body of begin with rescue but unreferenced + registers an offense + when a variable is assigned in main body of begin, rescue and else and reassigned in ensure then referenced after the begin + registers offenses for each assignment before ensure + when a variable is reassigned with binary operator assignment while assigning to itself in rhs then referenced + registers an offense for the assignment in rhs + when a variable is shadowed by a block argument and unreferenced + registers an offense + when a variable is assigned in each branch of if and referenced after the branching + accepts + when an unreferenced variable is reassigned in a block + accepts + when a variable is assigned at the end of rescue and would be referenced with retry + accepts + when an unreferenced variable is reassigned and re-referenced + registers an offense for the unreferenced assignment + similar name suggestion + when there's a similar method invocation with arguments + does not suggest any name + when there's a similar variable + suggests the variable name + when there's a similar variable-like method invocation + suggests the method name + when there's a similar method invocation with explicit receiver + does not suggest any name + when there's a similar name but it's in inner scope + does not suggest any name + when there are only less similar names + does not suggest any name + when a variable is reassigned multiple times in main body of begin then referenced in rescue + accepts + when a variable is assigned and assigned again in a modifier condition + accepts with parentheses + accepts without parentheses + when a variable is reassigned multiple times in rescue with ensure then referenced after the begin + registers an offense + when a keyword splat method argument is used + accepts + when a variable is reassigned while referencing itself in rhs and referenced + accepts + when a variable is not used and the name starts with _ + accepts + when there's an unreferenced reassignment in a if branch while the variable is referenced in a case branch in the paired else branch + registers an offense for the reassignment in the if branch + when a keyword splat method argument is not used + accepts + when there's an unreferenced assignment in top level if branch while the variable is referenced in the paired else branch + registers an offense for the assignment in the if branch + when a optional keyword method argument is not used + accepts + when a variable is reassigned in single branch if and referenced in the branch + registers an offense for the unreferenced assignment + when an anonymous keyword splat method argument is defined + accepts + when there's an unreferenced reassignment in a if branch while the variable is referenced in the paired elsif branch + registers an offense for the reassignment in the if branch + when a block method argument is not used + accepts + when a variable is assigned with ||= before the last expression of the scope + registers an offense + when a variable is assigned in loop body and referenced in post until condition + accepts + when a variable is assigned on each side of && and referenced after the && + accepts + when a variable is reassigned multiple times in main body of begin then referenced in ensure + accepts + when a rescued error variable is wrongly tried to be referenced in another rescue body + registers an offense + when a variable is assigned and unreferenced in a singleton method defined with variable name + registers an offense + when a referenced variable is reassigned in a block + accepts + when a variable is reassigned with logical operator assignment and referenced + accepts + when a variable is assigned with operator assignment in top level + registers an offense + when a block local variable is declared but not assigned + accepts + when a variable is assigned in loop body and unreferenced + registers an offense + when a variable is reassigned and unreferenced in a if branch while the variable is referenced in the paired else branch + registers an offense for the reassignment in the if branch + when a variable is reassigned with multiple assignment while referencing itself in rhs and referenced + accepts + when a variable is reassigned in a loop + post while loop + accepts + until loop + accepts + for loop + accepts + post until loop + accepts + while loop + accepts + when a variable is assigned and unreferenced in a method + registers an offense + when a variable is assigned and referenced when defining a module + does not register an offense + when a variable is assigned with operator assignment in rescue and would be referenced with retry + accepts + when a named capture is unreferenced in top level + registers an offense + when a variable is reassigned with binary operator assignment and referenced + accepts + when a variable is assigned and unreferenced in a module + registers an offense + when a method argument is reassigned and zero arity super is called + accepts + when a variable is reassigned in loop body but won't be referenced either next iteration or loop condition + registers an offense (PENDING: Requires an advanced logic that checks whether the return value of an operator assignment is used or not.) + when a splat method argument is not used + accepts + when a setter is invoked with operator assignment in loop body + accepts + +RuboCop::Cop::Style::MagicCommentFormat + invalid config + ValueCapitalization + raises an error + DirectiveCapitalization + raises an error + ValueCapitalization + when not set + does not change the case of magic comment directives + when uppercase + registers an offense and corrects when the case does not match + when lowercase + registers an offense and corrects when the case does not match + snake case style + accepts a magic comments in snake case + registers an offense for mixed case + registers an offense for kebab case in emacs style + accepts a frozen string literal in snake case in emacs style + does not register an offense for incorrect style in comments after the first statement + registers an offense for kebab case + accepts an empty source + does not register an offense for dashes in other comments + accepts a source with no tokens + kebab case style + accepts a magic comments in kebab case + accepts a source with no tokens + accepts a frozen string literal in snake case in emacs style + does not register an offense for dashes in other comments + registers an offense for snake case + does not register an offense for incorrect style in comments after the first statement + registers an offense for snake case in emacs style + accepts an empty source + registers an offense for mixed case + DirectiveCapitalization + when not set + does not change the case of magic comment directives + when uppercase + registers an offense and corrects when the case does not match + when lowercase + registers an offense and corrects when the case does not match + all issues at once + registers and corrects multiple issues + +RuboCop::Cop::Lint::RequireParentheses + accepts method call with parentheses in ternary + registers an offense for missing parentheses around expression with && operator + accepts parentheses around expression with boolean operator + accepts method calls that are all operations + accepts missing parentheses around expression with + operator + registers an offense for missing parentheses around expression with || operator + registers an offense for missing parentheses around expression in ternary + accepts calls to methods that are setters + accepts missing parentheses when using ternary operator in square bracksts + accepts calls to methods that are operators + accepts method calls without parentheses followed by keyword and/or + accepts missing parentheses when method is not a predicate + accepts missing parentheses when using ternary operator + accepts condition that is not a call + when using safe navigation operator + registers an offense for missing parentheses around expression with && operator + +RuboCop::Cop::Style::EmptyLiteral + Empty Hash + does not register an offense for Hash.new(3) + autocorrects Hash.new in block + does not register an offense for ::Hash.new { block } + autocorrects Hash.new to {} in various contexts + autocorrects Hash.new to {} as the first parameter to a method + registers an offense for Hash.new + does not register an offense for ::Hash.new(3) + autocorrects Hash.new to {} and wraps it in parentheses when it is the only argument to super + registers an offense for ::Hash.new + autocorrects Hash.new to {} and wraps all arguments in parentheses when it is the first argument to super + does not register an offense for Hash.new { block } + registers an offense for Hash.new() + autocorrects Hash.new to {} as the only parameter to a method + Ruby 2.7 + does not register an offense for ::Hash.new { _1[_2] = [] } + does not register an offense for Hash.new { _1[_2] = [] } + Empty Array + does not register an offense for Array.new(3) + registers an offense for Array.new + registers an offense for ::Array.new + does not register Array.new with block in other block + registers an offense for Array.new() + does not register an offense Array.new with block + does not register an offense for ::Array.new with block + autocorrects Array.new in block in block + Empty String + registers an offense for ::String.new + registers an offense for String.new + registers an offense for String.new() + does not register an offense for String.new("top") + does not register an offense for ::String.new("top") + when double-quoted string literals are preferred + registers an offense for ::String.new + registers an offense for String.new + when frozen string literals is enabled + does not register an offense for String.new + when Style/FrozenStringLiteral is enabled + and there is no magic comment + does not register an offense + and there is a frozen_string_literal: false comment + registers an offense and corrects + +RuboCop::Cop::InternalAffairs::StyleDetectedApiUse + does not register an offense when correct_style_detected and a opposite_style_detected are both used + registers an offense when correct_style_detected is used in a conditional expression + does not register an offense when correct_style_detected and a unrecognized_style_detected are both used + does not register an offense when correct_style_detected and a conflicting_styles_detected are both used + registers an offense when conflicting_styles_detected is used without a correct_style_detected follow up + registers an offense when correct_style_detected is used without a negative *_style_detected follow up + registers an offense when unexpected_style_detected is used in a conditional expression + registers an offense when unexpected_style_detected is used without a correct_style_detected follow up + registers an offense when opposite_style_detected is used in a conditional expression + does not register an offense when correct_style_detected and a unexpected_style_detected are both used + registers an offense when unrecognized_style_detected is used in a conditional expression + does not register an offense when correct_style_detected and a ambiguous_style_detected are both used + registers an offense when opposite_style_detected is used without a correct_style_detected follow up + registers an offense when conflicting_styles_detected is used in a conditional expression + registers an offense when no_acceptable_style! is used without a correct_style_detected follow up + registers an offense when unrecognized_style_detected is used without a correct_style_detected follow up + registers an offense when no_acceptable_style! is used in a conditional expression + registers an offense when ambiguous_style_detected is used without a correct_style_detected follow up + does not register an offense when correct_style_detected and a no_acceptable_style! are both used + registers an offense when ambiguous_style_detected is used in a conditional expression + +RuboCop::Cop::Style::RedundantException + accepts a raise with RuntimeError if it does not have 2 args + reports an offense for a fail with ::RuntimeError and () + reports an offense for a raise with ::RuntimeError and () + reports an offense for a fail with ::RuntimeError.new + accepts rescue w/ non redundant error + accepts a fail with RuntimeError if it does not have 2 args + reports an offense for a fail with RuntimeError.new + reports an offense for a raise with ::RuntimeError.new + accepts rescue w/ non redundant error + reports an offense for a raise with RuntimeError.new + reports an offense for a fail with ::RuntimeError.new + reports an offense for a fail with ::RuntimeError + reports an offense for a raise with RuntimeError and () + reports an offense for a raise with RuntimeError.new + reports an offense for a fail with RuntimeError.new + accepts rescue w/ non redundant error + reports an offense for a raise with ::RuntimeError.new + reports an offense for a fail with RuntimeError + accepts a raise with ::RuntimeError if it does not have 2 args + accepts rescue w/ non redundant error + reports an offense for a raise with RuntimeError + accepts a fail with ::RuntimeError if it does not have 2 args + reports an offense for a fail with RuntimeError and () + reports an offense for a raise with ::RuntimeError + +RuboCop::Cop::Team + #external_dependency_checksum + does not error with no cops + when a cop joins + returns string + when cop with different checksum joins + has a different checksum for the whole team + when multiple cops join + returns string + #forces + returns force instances + when a cop joined a force + returns the force + when multiple cops joined a same force + returns only one force instance + when no cops joined force + returns nothing + #debug? + when { debug: true } is passed to .new + is expected to be truthy + when the option argument of .new is omitted + is expected to be falsey + when incompatible cops are correcting together + autocorrects without SyntaxError + #cops + returns cop instances + when only some cop classes are passed to .new + returns only instances of the classes + when some classes are disabled with config + does not return instances of the classes + #inspect_file + returns offenses + when Parser reports non-fatal warning for the file + returns Parser warning offenses + returns offenses from cops + when a cop has no interest in the file + returns all offenses except the ones of the cop + when Cop#on_* raises an error + records Team#errors + when done twice + allows cops to get ready + when autocorrection is enabled + still returns offenses + does autocorrection + when autocorrection is enabled and file encoding is mismatch + no error occurs + when a correction raises an error + records Team#errors + #autocorrect? + when the option argument of .new is omitted + is expected to be falsey + when { autocorrect: true } is passed to .new + is expected to be truthy + .new + calls mobilize when passed classes + accepts cops directly classes + +RuboCop::Cop::Layout::FirstArrayElementIndentation + when array is method argument + and argument are not surrounded by parentheses + accepts a correctly indented multi-line array with brackets + accepts single line array with brackets + accepts indent based on the start of the line where the left bracket iswhen the right bracket and its following pair is on the same line + accepts indent based on the left bracket when the outer hash key and the left bracket is not on the same line + accepts bracketless array + registers an offense for incorrectly indented multi-line array that is the value of a single pair hash + registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key + registers an offense and corrects incorrectly indented multi-line array with brackets + and arguments are surrounded by parentheses + and EnforcedStyle is consistent + registers an offense and corrects incorrect indentation + registers an offense for incorrectly indented multi-line array that is the value of a single pair hash + accepts indent based on the left brace when the outer hash key and the left bracket is not on the same line + registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key + accepts normal indentation for first argument + accepts indent based on the start of the line where the left bracket iswhen the right bracket and its following pair is on the same line + accepts normal indentation for second argument + and EnforcedStyle is special_inside_parentheses + accepts special indentation for first argument + accepts special indentation for second argument + registers an offense for incorrectly indented multi-line array that is the value of a single pair hash + accepts normal indentation for array within array + registers an offense for a multi-line array that is a value of a multi pairs hash when the indent of its elements is not based on the hash key + registers an offense and corrects 'align_brackets' indentation + accepts indent based on the left brace when the outer hash key and the left bracket is not on the same line + registers an offense and corrects 'consistent' indentation + accepts indent based on the preceding left parenthesis when the right bracket and its following pair is on the same line + when using safe navigation operator + registers an offense and corrects 'consistent' indentation + when array is operand + accepts correctly indented first element + registers an offense and corrects incorrectly indented ] + registers an offense and corrects incorrectly indented first element + when indentation width is overridden for this cop + registers an offense and corrects incorrectly indented 1st element + accepts correctly indented first element + when EnforcedStyle is align_brackets + accepts multi-assignments with no brackets + accepts an empty array + accepts correctly indented first element + accepts single line array + accepts several elements per line + registers an offense and corrects incorrectly indented ] + accepts a first element on the same line as the left bracket + accepts multi-assignments with brackets + when indentation width is overridden for this cop + registers an offense and corrects indentation that does not match IndentationWidth + accepts correctly indented first element + when 'consistent' style is used + registers an offense and corrects incorrect indentation + registers an offense and corrects incorrectly indented 1st element + when 'special_inside_parentheses' style is used + registers an offense and corrects incorrect indentation + when array is right hand side in assignment + accepts a first element on the same line as the left bracket + registers an offense and corrects incorrectly indented first element + accepts several elements per line + accepts single line array + accepts an empty array + accepts correctly indented first element + accepts multi-assignments with brackets + accepts multi-assignments with no brackets + when array is argument to setter + accepts correctly indented first element + registers an offense and corrects incorrectly indented first element + +RuboCop::Cop::Layout::EmptyLinesAroundModuleBody + when EnforcedStyle is no_empty_lines + autocorrects beginning and end + registers an offense for module body starting with a blank + registers an offense for module body ending with a blank + when EnforcedStyle is empty_lines_except_namespace + when only child is module + registers offenses for namespaced module body not starting with a blank + registers offenses for namespaced module body not ending with a blank + autocorrects beginning and end + registers offense for namespace body ending with a blank + requires no empty lines for namespace + registers offense for namespace body starting with a blank + when has multiple child modules + registers offenses for namespace body starting and ending without a blank + requires empty lines for namespace + when only child is class + requires no empty lines for namespace + registers offense for namespace body ending with a blank + registers offense for namespace body starting with a blank + when EnforcedStyle is empty_lines + registers an offense for module body not starting or ending with a blank + registers an offense for module body not ending with a blank + accepts modules with an empty body + autocorrects beginning and end + when EnforcedStyle is empty_lines_special + module with empty body + without empty line + does NOT register offenses + with empty line + does NOT register offenses + when first child is an access modifier + with no blank lines at the beginning and ending of module body + registers and corrects an offense + with blank lines at the beginning and ending of module body + registers no offense + module with constant and child module + registers and autocorrects the offenses + when first child is NOT a method + does not require blank line at the beginning of module body but requires blank line before first def definition and requires blank line at the end of module body + when module has a namespace + requires no empty lines for namespace and does not require blank line at the beginning of module body but requires blank line at the end of module body + source without blank lines + registers and autocorrects the offenses + source with constants + registers and autocorrects the offenses + source with blank lines + registers and autocorrects the offenses + source with comment before method definition + registers an offense for module beginning with a blank line + source without blank lines + registers an offense for module not ending with a blank line + source with blank lines + registers an offense for module beginning with a blank line + when namespace has multiple children + requires empty lines for namespace + module with only constants + registers and autocorrects the offenses + when first child is a method + requires blank line at the beginning and ending of module body + when module has a namespace + requires no empty lines for namespace but requires blank line at the beginning and ending of module body + source without blank lines + registers and autocorrects the offenses + source with blank lines + autocorrects the offenses + source without blank lines + registers an offense for module not beginning and ending with a blank line + +RuboCop::Cop::Lint::UselessAccessModifier + behaves like nested modules + doesn't register an offense for nested classs + unused modifiers + registers an offense when outside a nested class + registers an offense with a nested class + registers an offense when inside a nested class + behaves like def in new block + registers an offense if no method is defined in ::Class.new + doesn't register an offense if a method is defined in ::Class.new + behaves like def in new block + registers an offense if no method is defined in ::Module.new + doesn't register an offense if a method is defined in ::Module.new + behaves like non-repeated visibility modifiers + doesn't register an offense when `protected` is not repeated + registers an offense and corrects even when `public` is not repeated + doesn't register an offense when `private` is not repeated + behaves like def in new block + doesn't register an offense if a method is defined in ::Module.new + registers an offense if no method is defined in ::Module.new + behaves like def in new block + doesn't register an offense if a method is defined in Struct.new + registers an offense if no method is defined in Struct.new + behaves like method defined with define_method + doesn't register an offense if a lambda is passed + doesn't register an offense if a block is passed + doesn't register an offense if a -> is passed + doesn't register an offense if a proc is passed + behaves like nested modules + doesn't register an offense for nested modules + unused modifiers + registers an offense when inside a nested module + registers an offense when outside a nested module + registers an offense with a nested module + behaves like nested in a begin..end block + still flags repeated `protected` + doesn't flag an access modifier from surrounding scope + when an access modifier has no effect + registers an offense and corrects + behaves like at the end of the body + registers an offense for trailing `public` + behaves like nested modules + doesn't register an offense for nested modules + unused modifiers + registers an offense when outside a nested module + registers an offense when inside a nested module + registers an offense with a nested module + behaves like nested in a begin..end block + doesn't flag an access modifier from surrounding scope + still flags repeated `private` + when class is empty save modifier + registers an offense and corrects + when passing method as symbol + does not register an offense + behaves like method defined using class_eval + doesn't register an offense if a method is defined + registers an offense if no method is defined + inside a class + registers an offense when a modifier is outside the block and a method is defined only inside the block + registers two offenses when a modifier is inside and outside the block and no method is defined + behaves like def in new block + registers an offense if no method is defined in ::Struct.new + doesn't register an offense if a method is defined in ::Struct.new + when private_class_method is used without arguments + registers an offense and corrects + behaves like def in new block + registers an offense if no method is defined in Struct.new + doesn't register an offense if a method is defined in Struct.new + behaves like methods defined in an iteration + doesn't register an offense for each + doesn't register an offense for map + behaves like method named by access modifier name + does not register an offense for `protected` + when a def is an argument to a method call + does not register an offense + behaves like nested in a begin..end block + still flags repeated `public` + behaves like method defined on a singleton class + inside a class + doesn't register an offense if a method is defined + doesn't register an offense if the modifier is the same as outside the meta-class + registers an offense if no method is defined after the modifier + registers an offense if no method is defined + registers an offense even if a non-singleton-class method is defined + outside a class + registers an offense if no method is defined + registers an offense if no method is defined after the modifier + doesn't register an offense if a method is defined + behaves like non-repeated visibility modifiers + doesn't register an offense when `protected` is not repeated + registers an offense and corrects even when `public` is not repeated + doesn't register an offense when `private` is not repeated + behaves like methods defined in an iteration + doesn't register an offense for each + doesn't register an offense for map + behaves like def in new block + doesn't register an offense if a method is defined in Module.new + registers an offense if no method is defined in Module.new + when there are consecutive access modifiers + registers an offense and corrects + behaves like def in new block + doesn't register an offense if a method is defined in Class.new + registers an offense if no method is defined in Class.new + behaves like def in new block + registers an offense if no method is defined in Class.new + doesn't register an offense if a method is defined in Class.new + behaves like at the top of the body + registers an offense and corrects for `public` + doesn't register an offense for `private` + doesn't register an offense for `protected` + behaves like at the end of the body + registers an offense for trailing `private` + behaves like repeated visibility modifiers + registers an offense when `protected` is repeated + when multiple class definitions in file but only one has offense + registers an offense and corrects + behaves like method defined with define_method + doesn't register an offense if a -> is passed + doesn't register an offense if a lambda is passed + doesn't register an offense if a proc is passed + doesn't register an offense if a block is passed + behaves like method named by access modifier name + does not register an offense for `private` + behaves like nested in a begin..end block + still flags repeated `private` + doesn't flag an access modifier from surrounding scope + behaves like repeated visibility modifiers + registers an offense when `protected` is repeated + behaves like method named by access modifier name + does not register an offense for `private` + behaves like at the end of the body + registers an offense for trailing `private` + behaves like unused visibility modifiers + registers an offense and corrects when visibility is immediately changed without any intervening defs + behaves like def in new block + doesn't register an offense if a method is defined in Module.new + registers an offense if no method is defined in Module.new + behaves like methods defined in an iteration + doesn't register an offense for each + doesn't register an offense for map + when using ActiveSupport's `concerning` method + still points out redundant uses within the block + is aware that this creates a new scope + Ruby 2.7 + still points out redundant uses within the block + behaves like repeated visibility modifiers + registers an offense when `public` is repeated + behaves like method named by access modifier name + does not register an offense for `public` + behaves like at the end of the body + registers an offense for trailing `protected` + behaves like nested modules + doesn't register an offense for nested classs + unused modifiers + registers an offense when inside a nested class + registers an offense when outside a nested class + registers an offense with a nested class + when private_class_method is used with arguments + does not register an offense + behaves like methods defined in an iteration + doesn't register an offense for map + doesn't register an offense for each + behaves like conditionally defined method + doesn't register an offense for unless + doesn't register an offense for if + behaves like nested in a begin..end block + still flags repeated `public` + behaves like repeated visibility modifiers + registers an offense when `public` is repeated + behaves like method defined on a singleton class + inside a class + registers an offense even if a non-singleton-class method is defined + doesn't register an offense if the modifier is the same as outside the meta-class + doesn't register an offense if a method is defined + registers an offense if no method is defined + registers an offense if no method is defined after the modifier + outside a class + doesn't register an offense if a method is defined + registers an offense if no method is defined after the modifier + registers an offense if no method is defined + when an access modifier is followed by a class method defined on constant + registers an offense and corrects + behaves like def in new block + registers an offense if no method is defined in ::Class.new + doesn't register an offense if a method is defined in ::Class.new + behaves like conditionally defined method + doesn't register an offense for if + doesn't register an offense for unless + behaves like at the end of the body + registers an offense for trailing `public` + behaves like conditionally defined method + doesn't register an offense for if + doesn't register an offense for unless + when only a constant or local variable is defined after the modifier + registers an offense and corrects + registers an offense and corrects + behaves like method defined using instance_eval + registers an offense if no method is defined + doesn't register an offense if a method is defined + inside a class + registers an offense when a modifier is outside the block and a method is defined only inside the block + registers two offenses when a modifier is inside and outside the and no method is defined + when using the class_methods method from ActiveSupport::Concern + is aware that this creates a new scope + when an access modifier has no methods + registers an offense and corrects + behaves like repeated visibility modifiers + registers an offense when `private` is repeated + behaves like unused visibility modifiers + registers an offense and corrects when visibility is immediately changed without any intervening defs + behaves like def in new block + registers an offense if no method is defined in ::Struct.new + doesn't register an offense if a method is defined in ::Struct.new + when using ActiveSupport behavior when Rails is not eabled + reports offenses and corrects + when an access modifier is followed by attr_* + does not register an offense + behaves like method defined using instance_eval + doesn't register an offense if a method is defined + registers an offense if no method is defined + inside a class + registers two offenses when a modifier is inside and outside the and no method is defined + registers an offense when a modifier is outside the block and a method is defined only inside the block + behaves like conditionally defined method + doesn't register an offense for unless + doesn't register an offense for if + behaves like method named by access modifier name + does not register an offense for `public` + when using inline modifiers + does not register an offense + when using a known method-creating method + still points out redundant uses within the module + is aware that this creates a new method + behaves like nested in a begin..end block + still flags repeated `protected` + doesn't flag an access modifier from surrounding scope + behaves like method defined on a singleton class + inside a class + registers an offense if no method is defined after the modifier + doesn't register an offense if a method is defined + doesn't register an offense if the modifier is the same as outside the meta-class + registers an offense if no method is defined + registers an offense even if a non-singleton-class method is defined + outside a class + registers an offense if no method is defined + registers an offense if no method is defined after the modifier + doesn't register an offense if a method is defined + behaves like method named by access modifier name + does not register an offense for `protected` + behaves like repeated visibility modifiers + registers an offense when `private` is repeated + behaves like method defined on a singleton class + outside a class + doesn't register an offense if a method is defined + registers an offense if no method is defined after the modifier + registers an offense if no method is defined + inside a class + registers an offense if no method is defined after the modifier + registers an offense if no method is defined + doesn't register an offense if the modifier is the same as outside the meta-class + registers an offense even if a non-singleton-class method is defined + doesn't register an offense if a method is defined + behaves like at the end of the body + registers an offense for trailing `protected` + behaves like method defined using class_eval + doesn't register an offense if a method is defined + registers an offense if no method is defined + inside a class + registers an offense when a modifier is outside the block and a method is defined only inside the block + registers two offenses when a modifier is inside and outside the block and no method is defined + behaves like method defined with define_method + doesn't register an offense if a proc is passed + doesn't register an offense if a -> is passed + doesn't register an offense if a block is passed + doesn't register an offense if a lambda is passed + behaves like at the top of the body + doesn't register an offense for `private` + doesn't register an offense for `protected` + registers an offense and corrects for `public` + behaves like method defined with define_method + doesn't register an offense if a proc is passed + doesn't register an offense if a block is passed + doesn't register an offense if a -> is passed + doesn't register an offense if a lambda is passed + +RuboCop::Cop::Style::OperatorMethodCall + registers an offense when chaining `foo.bar.^(baz).round(2)` + registers an offense when using `foo.< bar` + does not register an offense when using `foo % bar` + registers an offense when chaining `foo.bar.*(baz).round(2)` + registers an offense when using `foo.>(bar)` + registers an offense when using `foo.!~(bar)` + registers an offense when using `foo.+ bar` + registers an offense when chaining `foo.bar.|(baz).round(2)` + does not register an offense when using `foo - bar` + registers an offense when chaining `foo.bar.<=(baz).round(2)` + registers an offense when using `foo.<= bar` + registers an offense when using `foo.=~(bar)` + does not register an offense when using `foo < bar` + registers an offense when using `foo.== bar` + does not register an offense when using `foo ! bar` + does not register an offense when using `foo + bar` + registers an offense when using `foo./(bar)` + registers an offense when chaining `foo.bar.!~(baz).round(2)` + does not register an offense when using `foo.+@bar` + does not register an offense when using `foo ~ bar` + registers an offense when chaining `foo.bar.>>(baz).round(2)` + registers an offense when using `foo.<=(bar)` + registers an offense when using `foo.% bar` + registers an offense when using `foo.- bar` + registers an offense when chaining `foo.bar.=~(baz).round(2)` + does not register an offense when using `foo * bar` + registers an offense when chaining `foo.bar.<(baz).round(2)` + registers an offense when using `foo.===(bar)` + does not register an offense when using `foo ^ bar` + registers an offense when using `foo.** bar` + registers an offense when using `foo./ bar` + registers an offense when using `foo.^ bar` + registers an offense when using `foo.!(bar)` + registers an offense when using `foo.!=(bar)` + registers an offense when chaining `foo.bar.>=(baz).round(2)` + registers an offense when chaining `foo.bar.===(baz).round(2)` + registers an offense when using `foo.!= bar` + registers an offense when using `foo.<<(bar)` + registers an offense when using `foo.> bar` + registers an offense when using `foo.=~ bar` + does not register an offense when using `foo >= bar` + does not register an offense when using `foo == bar` + does not register an offense when using `foo << bar` + does not register an offense when using `Foo.+(bar)` + registers an offense when using `foo.-(bar)` + registers an offense when using `foo.*(bar)` + registers an offense when using `foo.+(bar)` + does not register an offense when using `foo.`bar` + registers an offense when using `foo.>> bar` + registers an offense when chaining `foo.bar./(baz).round(2)` + registers an offense when using `foo.~(bar)` + registers an offense when using `foo.%(bar)` + registers an offense when using `foo.| bar` + does not register an offense when using `foo === bar` + does not register an offense when using `foo > bar` + registers an offense when using `foo.<(bar)` + does not register an offense when using `foo | bar` + registers an offense when chaining `foo.bar.<<(baz).round(2)` + registers an offense when chaining `foo.bar.==(baz).round(2)` + registers an offense when using `foo.* bar` + registers an offense when using `foo.<=> bar` + registers an offense when using `foo.&(bar)` + registers an offense when using `foo.=== bar` + registers an offense when chaining `foo.bar.>(baz).round(2)` + registers an offense when chaining `foo.bar.%(baz).round(2)` + registers an offense when using `foo.^(bar)` + registers an offense when using `foo.<=>(bar)` + registers an offense when using `foo.|(bar)` + registers an offense when using `foo.& bar` + does not register an offense when using `foo !~ bar` + registers an offense when chaining `foo.bar.&(baz).round(2)` + registers an offense when chaining `foo.bar.**(baz).round(2)` + does not register an offense when using `foo.~@bar` + does not register an offense when using `foo <=> bar` + does not register an offense when using `foo <= bar` + registers an offense when chaining `foo.bar.~(baz).round(2)` + does not register an offense when using `foo.+@bar.to_s` + registers an offense when using `foo.~ bar` + registers an offense when using `foo.==(bar)` + registers an offense when chaining `foo.bar.!=(baz).round(2)` + registers an offense when using `foo.<< bar` + does not register an offense when using `obj.!` + registers an offense when chaining `foo.bar.-(baz).round(2)` + does not register an offense when using `foo != bar` + does not register an offense when using `foo.-@bar` + does not register an offense when using `foo ** bar` + registers an offense when using `foo.**(bar)` + registers an offense when using `foo.>= bar` + registers an offense when chaining `foo.bar.<=>(baz).round(2)` + registers an offense when using `foo.! bar` + registers an offense when chaining `foo.bar.!(baz).round(2)` + does not register an offense when using `foo / bar` + registers an offense when using `foo.>=(bar)` + does not register an offense when using `foo & bar` + does not register an offense when using `foo >> bar` + registers an offense when chaining `foo.bar.+(baz).round(2)` + registers an offense when using `foo.>>(bar)` + does not register an offense when using `foo =~ bar` + registers an offense when using `foo.!~ bar` + does not register an offense when using `foo.!@bar` + +RuboCop::Cop::Lint::IncompatibleIoSelectWithFiberScheduler + registers and corrects an offense when using `IO.select` with single read argument and specify the first argument only + does not register an offense when using `Enumerable#select` + registers and corrects an offense when using `IO.select` with multiple read argument and specify the first argument only + registers and corrects an offense when using `IO.select` with single read and timeout arguments + registers and corrects an offense when using `IO.select` with single write as `self` and timeout arguments + registers and corrects an offense when using `::IO.select` with single read and timeout arguments + does not register an offense when using `IO.select` with multiple read arguments + registers and corrects an offense when using `IO.select` with single write argument + registers and corrects an offense when using `::IO.select` with single read argument + registers and corrects an offense when using `IO.select` with single write and timeout arguments + registers and corrects an offense when using `IO.select` with single read, `nil`, and timeout arguments + does not register an offense when using `IO.select` with multiple write arguments + registers and corrects an offense when using `IO.select` with single write, `nil`, and timeout arguments + registers an offense when using `IO.select` with read argument and using return value but does not autocorrect + registers and corrects an offense when using `IO.select` with single read argument + registers an offense when using `IO.select` with write argument and using return value but does not autocorrect + does not register an offense when using `IO.select` with read and write arguments + registers and corrects an offense when using `IO.select` with single read as `self` and timeout arguments + +RuboCop::Cop::Lint::NonLocalExitFromIterator + allows return with value + allows return in define_singleton_method + allows return in define_method + when block is not followed by method chain + allows + when block is lambda + allows + when block in middle of nest is followed by method chain + registers offenses + when block is followed by method chain + and has single argument + registers an offense + and has multiple arguments + registers an offense + and has no argument + allows + when the return is within a nested method definition + allows return in a class method definition + allows return in an instance method definition + when lambda is inside of block followed by method chain + allows + +RuboCop::Cop::Lint::TripleQuotes + does not register an offense for implicit concatenation + heredocs + does not register an offense + quintuple quotes + registers an offense and corrects + string interpolation + does not register an offense + with nested extra quotes + registers an offense and corrects + triple quotes + with only whitespace + does not register + when only quotes + registers an offense and corrects to a single empty quote + on multiple lines + registers an offense and corrects + on one line + registers an offense and corrects + +RuboCop::Cop::Layout::MultilineMethodCallIndentation + when EnforcedStyle is indented_relative_to_receiver + accepts indentation of consecutive lines in typical RSpec code + doesn't crash on unaligned multiline lambdas + does not register an offense when multiline method chain has expected indent width and the method is preceded by splat + registers an offense and corrects proc call without a selector + accepts indentation relative to first receiver + doesn't fail on unary operators + accepts alignment inside a grouped expression + does not register an offense when multiline method chain has expected indent width and the method is preceded by double splat + registers an offense and corrects one space indentation of 2nd line + accepts indented methods in for body + accepts correctly indented methods in operation + registers an offense and corrects 3 spaces indentation of second line + accepts an expression where the first method spans multiple lines + registers an offense and corrects extra indentation of 3rd line in typical RSpec code + accepts no extra indentation of third line + registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array + registers an offense and corrects no indentation of second line + registers an offense and corrects extra indentation of 3rd line + accepts indented methods inside and outside a block + accepts indented methods in ordinary statement + accepts indented methods in LHS of []= assignment + accepts alignment of method with assignment and operator-like method + accepts any indentation of parameters to #[] + for possible semantic alignment + accepts indented methods + when EnforcedStyle is indented + registers an offense and corrects aligned methods in if condition + accepts alignment of method with assignment and operator-like method + accepts indentation of assignment to obj.a[:key] with newline after = + registers an offense and corrects 3 spaces indentation of 2nd line + registers an offense for a 2 space indentation of if condition + accepts indented methods in if body + accepts indented methods in while body + accepts no extra indentation of third line + accepts normal indentation of method parameters + accepts any indentation of parameters to #[] + accepts alignment inside a grouped expression + registers an offense and corrects one space indentation of 2nd line + accepts special indentation of return if condition + doesn't fail on unary operators + accepts special indentation of for expression + accepts an expression where the first method spans multiple lines + accepts even indentation of consecutive lines in typical RSpec code + accepts indentation of assignment to a[:key] with newline after = + accepts special indentation of return unless condition + doesn't crash on unaligned multiline lambdas + accepts any indentation of method parameters + registers an offense and corrects correct + unrecognized style + accepts double indentation of while condition + registers an offense and corrects proc call without a selector + accepts indented methods in until body + accepts indented methods in for body + accepts indented methods inside and outside a block + accepts indented methods in unless body + accepts correctly indented methods in operation + accepts normal indentation inside grouped expression + registers an offense and corrects 0 space indentation inside square brackets + accepts indentation of assignment to obj.a with newline after = + accepts indented methods in ordinary statement + accepts indentation of assignment to a with rhs on same line + registers an offense for a 2 space indentation of until condition + accepts indented methods in LHS of []= assignment + accepts indentation of assignment to a with newline after = + accepts double indentation of if condition + registers an offense and corrects aligned operators in assignment + registers an offense for a 2 space indentation of while condition + accepts indentation of assignment to a[:key] with rhs on same line + registers an offense and corrects no indentation of second line + accepts double indentation of unless condition + registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array + accepts indentation relative to first receiver + registers an offense for a 2 space indentation of unless condition + registers an offense and corrects extra indentation of 3rd line in typical RSpec code + registers an offense and corrects 1 space indentation of 3rd line + registers an offense and corrects extra indentation of third line + registers an offense and corrects wrong indentation of for expression + accepts double indentation of until condition + accepts indented methods in if condition + when indentation width is overridden for this cop + accepts indentation of while condition which is offset by a single normal indentation step + accepts indented methods in while body + accepts indented methods in unless body + accepts indentation of until condition which is offset by a single normal indentation step + accepts indented methods in if condition + accepts indented methods in if body + accepts indented methods in until body + accepts indented methods + accepts indentation of assignment + accepts correctly indented methods in operation + registers an offense for a 4 space indentation of unless condition + accepts indentation of if condition which is offset by a single normal indentation step + accepts indentation of unless condition which is offset by a single normal indentation step + registers an offense for a 4 space indentation of while condition + registers an offense for a 4 space indentation of until condition + registers an offense for a 4 space indentation of if condition + for possible semantic alignment + accepts indented methods + when EnforcedStyle is aligned + accepts indented methods in ordinary statement + registers an offense and corrects one space indentation of 2nd line + accepts even indentation of consecutive lines in typical RSpec code + doesn't fail on unary operators + accepts no extra indentation of third line + registers an offense and corrects extra indentation of 3rd line in typical RSpec code + registers an offense and corrects extra indentation of third line + doesn't crash on unaligned multiline lambdas + registers an offense and corrects misaligned methods in unless condition + registers an offense and corrects proc call without a selector + accepts correctly aligned methods in assignment + accepts indented methods in LHS of []= assignment + accepts indented and aligned methods in binary operation + registers an offense and corrects no indentation of second line + accepts aligned methods in operator assignment + accepts alignment inside a grouped expression + accepts an expression where the first method spans multiple lines + accepts indented methods in for body + accepts aligned method in return + accepts aligned methods in if condition + registers an offense and corrects misaligned methods in if condition + registers an offense and corrects misaligned method in []= call + accepts any indentation of parameters to #[] + accepts indented method when there is nothing to align with + registers an offense and corrects one space indentation of 3rd line + registers an offense and corrects unaligned methods in assignment + registers an offense and corrects 3 spaces indentation of 2nd line + accepts aligned method in assignment + block + assignment + registers an offense and corrects misaligned methods in local variable assignment + accepts aligned methods in a begin..end block + registers an offense and corrects misaligned methods in until condition + registers an offense and corrects misaligned methods in while condition + accepts correctly aligned methods in operands + does not check binary operations when string wrapped with + + accepts aligned methods in constant assignment + accepts aligned methods in if + assignment + registers an offense and corrects the emacs ruby-mode 1.1 indentation of an expression in an array + accepts indentation relative to first receiver + does not check binary operations when string wrapped with backslash + accepts indented methods inside and outside a block + accepts aligned methods in assignment + accepts alignment of method with assignment and operator-like method + for semantic alignment + accepts 3 aligned methods + accepts aligned method even when an aref is in the chain + doesn't fail on a chain of aref calls + accepts method being aligned with method + accepts aligned method even when an aref is first in the chain + accepts methods being aligned with method that is an argument in assignment + accepts key access to hash + accepts method being aligned with method in assignment + registers an offense and corrects unaligned methods + accepts methods being aligned with method that is an argument + accepts nested method calls + accepts aligned method with blocks in operation assignment + registers an offense and corrects unaligned method in block body + >= Ruby 2.7 + accepts methods being aligned with method that is an argumentwhen using numbered parameter + +RuboCop::Cop::Style::ArgumentsForwarding + TargetRubyVersion >= 2.7 + does not register an offense when referencing the restarg outside forwarding method arguments + does not register an offense when using arguments forwarding + registers an offense when using restarg and block arg + does not register an offense when the block arg is overwritten + registers an offense when the parentheses of arguments are omitted + registers an offense when using restarg, kwargs and block arg + registers an offense when forwarding to a method in block + does not register an offense when using the restarg outside forwarding method arguments + registers an offense when delegating + does not register an offense when the restarg is overwritten + does not register an offense when different arguments are used + does not register an offense when assigning the restarg outside forwarding method arguments + registers an offense when passing restarg and block arg in defs + does not register an offense when body of method definition is empty + does not register an offense when different argument names are used + does not register an offense when the kwarg is overwritten + AllowOnlyRestArgument: false + registers an offense when using only kwrest arg + registers an offense when using only rest arg + AllowOnlyRestArgument: true + does not register an offense when using only rest arg + does not register an offense when using only kwrest arg + TargetRubyVersion <= 2.6 + does not register an offense when using restarg with block arg + TargetRubyVersion >= 3.1 + registers an offense when using restarg, kwargs, and anonymous block arg + registers an offense when using restarg and anonymous block arg + +RuboCop::Cop::Lint::ToEnumArguments + does not register an offense when not inside method definition + registers an offense when splat arg is missing + does not register an offense when method call has a receiver other than `self` + registers an offense when optional keyword arg is missing + ignores the block argument + registers an offense when method is called on `self` + does not register an offense when enumerator is created with `__callee__` and the correct arguments + registers an offense when enumerator is created for `__method__` with missing arguments + registers an offense when splat keyword arg is missing + registers an offense when enumerator is created for another method + registers an offense when required keyword arg is missing + does not register an offense when enumerator is created with `__method__` and the correct arguments + registers an offense when required arg is missing + does not register an offense when enumerator is created with `:m` and the correct arguments + registers an offense when other values are passed for keyword arguments + registers an offense when optional arg is missing + registers an offense when arguments are swapped + arguments forwarding + does not register an offense when enumerator is created with the correct arguments + registers an offense when enumerator is created with non matching arguments + +RuboCop::Cop::Metrics::ParameterLists + does not register an offense when method has allowed amount of args with block arg + does not register an offense when method has no args + does not register an offense when method has allowed amount of optargs + registers an offense for a method def with 5 parameters + registers an offense when optargs count exceeds the maximum + accepts a lambda with more than 4 parameters + accepts a proc with more than 4 parameters + accepts a method def with 4 parameters + When CountKeywordArgs is true + counts keyword arguments as well + When CountKeywordArgs is false + does not count keyword arguments without default values + does not count keyword arguments + +RuboCop::Cop::Lint::OrderedMagicComments + does not register an offense when using `frozen_string_literal` magic comment only + registers an offense and corrects when an `encoding` magic comment does not precede all other magic comments + does not register an offense when using `encoding` magic comment is first line + does not register an offense when using `encoding` magic comment only + registers an offense and corrects when `-*- encoding : ascii-8bit -*-` magic comment does not precede all other magic comments + registers an offense and corrects when `coding` magic comment does not precede all other magic comments + registers an offense and corrects when using `frozen_string_literal` magic comment is next of shebang + does not register an offense when using `encoding` magic comment is next of shebang + does not register an offense when using `encoding: Encoding::SJIS` Hash notation after`frozen_string_literal` magic comment + +RuboCop::Cop::Lint::StructNewOverride + registers an offense using `Struct.new(...)` with a block + registers an offense using `Struct.new(symbol, string)` + registers an offense using `Struct.new(symbol)` + registers an offense using `::Struct.new(symbol)` + registers an offense using `Struct.new(...)` with an option argument + does not register an offense with an override within a given block + registers an offense using `Struct.new(string, ...symbols)` + does not register an offense with no overrides + registers an offense using `Struct.new(...symbols)` + registers an offense using `Struct.new(...)` with multiple overrides + +RuboCop::Cop::Layout::EmptyLines + registers an offense for consecutive empty lines + does not register an offense for comments + does not register an offense for empty lines in a string + does not register an offense when there are no tokens + does not register an offense for heredocs with empty lines inside + +isolated environment + is not affected by a config file above the work directory + +RuboCop::Cop::Layout::DefEndAlignment + when EnforcedStyleAlignWith is def + accepts matching def ... end + accepts matching defs ... end + registers an offense for mismatched def test end and autocorrects + registers an offense for mismatched def Test.test end and autocorrects + registers an offense for mismatched foo def test end and autocorrects + accepts matching foo def ... end + correct + opposite + registers an offense + when EnforcedStyleAlignWith is start_of_line + accepts matching def ... end + accepts matching defs ... end + registers an offense for mismatched foo def test end and autocorrects + registers an offense for mismatched def test end and autocorrects + accepts matching def ... end + accepts matching foo def ... end + accepts matching foo bar def ... end + registers an offense for mismatched def Test.test end and autocorrects + when using refinements and `private def` + does not register an offense + correct + opposite + registers an offense + when including an anonymous module containing `private def` + does not register an offense + +RuboCop::Cop::Registry + can be cloned + exposes a list of cop names + exposes cop departments + can filter down to all but one type + exposes a mapping of cop names to cop classes + can filter down to one type + exposes the number of stored cops + #enabled + selects cops which are enabled in the config + selects only safe cops if :safe passed + overrides config if :only includes the cop + when new cops are introduced + does not include them + overrides config if :only includes the cop + when specifying `--enable-pending-cops` command-line option + includes them + when specifying `NewCops: disable` option in .rubocop.yml + includes them because command-line option takes precedence over .rubocop.yml + when specifying `NewCops: disable` option in .rubocop.yml + does not include them + when specifying `NewCops: enable` option in .rubocop.yml + includes them + when specifying `--disable-pending-cops` command-line option + does not include them + when specifying `NewCops: enable` option in .rubocop.yml + does not include them because command-line option takes precedence over .rubocop.yml + when specifying `NewCops: pending` option in .rubocop.yml + does not include them + when dismissing a cop class + allows it if done rapidly + allows re-listing + disallows it if done too late + names_for_department + returns array of cops for specified department + #qualified_cop_name + gives back already properly qualified names + raises an error when a cop name is ambiguous + qualifies names without a namespace + emits a warning when namespace is incorrect + returns the provided name if no namespace is found + qualifies names with the correct namespace + #cops + exposes a list of cops + with cops having the same inner-most module + exposes both cops + #contains_cop_matching? + returns false for cops not included in the store + can find cops matching a given name + #department? + returns false for other names + returns true for department name + +RuboCop::Cop::Style::TrailingBodyOnMethodDefinition + does not register offense with trailing body on method end + autocorrects with comment after body + accepts a method with multiple lines of body + registers when body starts on def line & continues one more line + autocorrects body with method definition with args not in parens + registers an offense when body trails after method definition + accepts a method with one line of body + registers when body starts on def line & continues many more lines + removes semicolon from method definition but not body when autocorrecting + Ruby 3.0 or higher + does not register offense when endless method definition body is after newline in opening parenthesis + when method is not on first line of processed_source + autocorrects offense + +RuboCop::Cop::Style::ArrayJoin + autocorrects '*' to 'join' when setting to a variable + registers an offense for an array followed by string + does not register an offense for numbers + autocorrects '*' to 'join' when there are no spaces + does not register an offense for ambiguous cases + +RuboCop::Cop::Style::MultipleComparison + registers an offense and corrects when `a` is compared three times, once on the righthand side + does not register an offense for a duplicated condition + registers an offense and corrects when `a` is compared three times + does not register an offense for comparing lvars when a string is on the lefthand side + does not register an offense for comparing multiple literal strings + registers an offense and corrects when multiple comparison is not part of a conditional + does not register an offense when comparing two sides of the disjunction is unrelated + does not register an offense for comparing multiple int literals + does not register an offense for a == b || b == a + does not register an offense for Array#include? + registers an offense and corrects when `a` is compared three times on the right hand side + registers an offense and corrects when `a` is compared twice + registers an offense and corrects when `a` is compared twice in `if` and `elsif` conditions + does not register an offense for comparing an lvar + does not register an offense for comparing lvars + when `AllowMethodComparison: false` + registers an offense and corrects when using multiple method calls + when `AllowMethodComparison: true` + does not register an offense when using multiple method calls + +RuboCop::Cop::Layout::ConditionPosition + accepts condition on a different line for modifiers + registers an offense and corrects for condition on the next line + registers an offense and corrects for elsif condition on the next line + accepts ternary ops + accepts condition on the same line + accepts condition on the same line + accepts condition on a different line for modifiers + registers an offense and corrects for condition on the next line + registers an offense and corrects for condition on the next line + accepts condition on a different line for modifiers + accepts condition on the same line + registers an offense and corrects for condition on the next line + accepts condition on the same line + accepts condition on a different line for modifiers + +RuboCop::CLI --auto-gen-config + --auto-gen-config + generates EnforcedStyle parameter if it solves all offenses + can generate Exclude properties with a given limit + includes --auto-gen-only-exclude in the command comment when given + does not generate configuration for the Syntax cop + generates Exclude instead of Max when --auto-gen-only-exclude is used + overwrites an existing todo file + generates a todo list that removes the reports + does not include offense counts when --no-offense-counts is used + generates Exclude if no EnforcedStyle solves all offenses + can be called when there are no files to inspection + honors rubocop:disable comments + can generate a todo list + does not include a timestamp when --no-auto-gen-timestamp is used + when --config is used + can generate a todo list if default .rubocop.yml exists + can generate a todo list + when different styles appear in different files + generates Exclude list if --exclude-limit is not exceeded + disables cop if --exclude-limit is exceeded + when inheriting from a URL + when there is a single entry + can generate a todo list + when there are multiple entries + can generate a todo list + when .rubocop.yml inherits from another file and .rubocop_todo.yml + bases other cops' configuration on the code base's current maximum line length + for existing configuration with Exclude + leaves out Excludes that appear in .rubocop.yml but are merged globally + generates Excludes that appear in .rubocop.yml + leaves out Excludes that appear in .rubocop.yml but are merged for the cop + console output + displays report summary but no offenses + when .rubocop.yml doesn't inherit + bases other cops' configuration on the code base's current maximum line length + with Layout/LineLength:Max overridden + when .rubocop.yml has Layout/LineLength:Max more than code base max + bases other cops' configuration on the overridden LineLength:Max + when .rubocop.yml has Layout/LineLength disabled + skips the cop from both phases of the run + when .rubocop.yml has Layout/LineLength:Max less than code base max + bases other cops' configuration on the overridden LineLength:Max + when cop is not safe to autocorrect + can generate a todo list, with the appropriate flag + when .rubocop.yml inherits only from .rubocop_todo.yml in an array + bases other cops' configuration on the code base's current maximum line length + when duplicated default configuration parameter + parameters are displayed without duplication + when hash value omission enabled + generates Exclude if it solves all offenses + when .rubocop.yml does not exist + bases other cops' configuration on the code base's current maximum line length + when .rubocop.yml is empty + bases other cops' configuration on the code base's current maximum line length + when .rubocop.yml inherits from two other files + bases other cops' configuration on the code base's current maximum line length + when .rubocop.yml inherits from another file + bases other cops' configuration on the code base's current maximum line length + when --no-exclude-limit is given + always prefers Exclude to Enabled + when working with a cop who do not support autocorrection + can generate a todo list + when working in a subdirectory + can generate a todo list + when .rubocop.yml inherits only from .rubocop_todo.yml + bases other cops' configuration on the code base's current maximum line length + when existing config file has a YAML document start header + inserts `inherit_from` key after hearder + +RuboCop::Cop::Style::AutoResourceCleanup + does not register an offense for File.open with block + does not register an offense for File.open with block-pass + does not register an offense for File.open with immediate close + registers an offense for File.open without block + +RuboCop::Cop::Layout::ClassStructure + registers an offense and corrects when literal constant is after method definitions + registers an offense and corrects when str heredoc constant is defined after public method + registers an offense and corrects when xstr heredoc constant is defined after public method + registers an offense and corrects when there is a comment in the macro method + registers an offense and corrects when dstr heredoc constant is defined after public method + when the first line ends with a comment + reports an offense and swaps the lines + with attribute macros before after validations + is expected to eq class Person + include AnotherModule + extend SomeModule + + CustomError = Cla...rivate :other_public_method + + private + + def some_private_method + end + end + with a complete ordered example + does not create offense + with protected methods declared before private + is expected to eq class MyClass + def public_method + end + + private + + def first_private...ar before `private_methods`. + end + + def second_protected_method + end + end + initializer is private and comes after attribute macro + registers an offense and autocorrects + constant is not a literal + registers offense but does not autocorrect + when def modifier is used + registers an offense and corrects public method after private method marked by its name + registers an offense and corrects public method with modifier declared after private method with modifier + registers an offense and corrects public method without modifier declared after private method with modifier + simple example + is expected to eq "class Person\n include AnotherModule\n extend SomeModule\n CONST = 'wrong place'\nend\n" + +RuboCop::Cop::Lint::PercentStringArray + with invalid byte sequence in UTF-8 + accepts if tokens contain invalid byte sequence only + add an offense and corrects when tokens contain quotes + with binary encoded source + accepts if tokens contain no quotes + adds an offense and corrects when tokens contain quotes + detecting quotes or commas in a %w/%W string + adds an offense and corrects when one token is quoted but there are no commas + accepts likely false positive %W(' " ! = # ,) + accepts likely false positive %w(' " ! = # ,) + accepts likely false positive :"#{a}" + accepts likely false positive %w(' ") + accepts likely false positive %w(#{a} b) + accepts likely false positive %W(#{a} b) + adds an offense and corrects when one token is quoted but there are no commas + accepts tokens without quotes or commas + adds an offense and corrects when there are no quotes but one comma + adds an offense and corrects when tokens contain both types of quotes + accepts likely false positive %W(' ") + accepts tokens without quotes or commas + accepts likely false positive :"#{a}" + adds an offense and corrects when there are no quotes but one comma + adds an offense and corrects when tokens contain quotes and are comma separated + adds an offense and corrects when tokens contain quotes and are comma separated + adds an offense and corrects when tokens contain both types of quotes + +RuboCop::Cop::Lint::EmptyWhen + when `AllowComments: true` + accepts an empty when body with a comment + registers an offense for missing when body without a comment + accepts an empty when ... then body with a comment + when a `when` body is present + accepts case with when bodies and else clause + accepts case with when ... then statements + accepts case with when ... then statements and else clause + accepts case with when bodies + accepts with no case line expression + when a `when` body is missing + registers an offense for missing when body followed by else + registers an offense for missing when ... then body + registers an offense when case line has no expression + registers an offense for missing when body with a comment followed by else + registers an offense for missing when body with a comment + registers an offense for a missing when body + registers an offense for missing when ... then body followed by else + when `AllowComments: false` + registers an offense for empty when body with a comment + +RuboCop::Cop::Style::HashTransformValues + below Ruby 2.6 + does not flag _.to_h{...} + when using Ruby 2.6 or newer + does not flag _.to_h {...} when value block argument is unused + does not flag `_.to_h{...}` when its receiver is an array literal + register and corrects an offense _.to_h{...} when value is a hash literal and is enclosed in braces + register and corrects an offense _.to_h{...} when value is a hash literal and is not enclosed in braces + flags _.to_h{...} when transform_values could be used + does not flag `_.to_h{...}` when both key & value are transformed + does not flag `_.to_h{...}` when its receiver is `with_index` + does not flag `_.to_h{...}` when its receiver is `zip` + does not flag `_.to_h{...}` when its receiver is `each_with_index` + below Ruby 2.4 + does not flag even if transform_values could be used + when using Ruby 2.4 or newer + does not flag `each_with_object` when its receiver is `with_index` + correctly autocorrects _.map{...}.to_h with block + does not flag `Hash[_.map{...}]` when its receiver is `zip` + does not flag Hash[_.map{...}] when both key & value are transformed + does not flag each_with_object when receiver is array literal + does not flag `Hash[_.map{...}]` when its receiver is `each_with_index` + does not flag `each_with_object` when its receiver is `each_with_index` + does not flag `Hash[_.map{...}]` when its receiver is an array literal + does not flag `Hash[_.map{...}]` when its receiver is `with_index` + does not flag `_.map{...}.to_h` when its receiver is `each_with_index` + does not flag _.map{...}.to_h when both key & value are transformed + does not flag value transformation when receiver is array literal + does not flag each_with_object when both key & value are transformed + does not flag _.map {...}.to_h when value block argument is unused + does not flag each_with_object when value transformation uses key + does not flag each_with_object when its argument is not modified + does not flag `each_with_object` when its receiver is `zip` + flags _.map {...}.to_h when transform_values could be used when wrapped in another block + does not flag value transformation in the absence of to_h + flags _.map {...}.to_h when transform_values could be used when line break before `to_h` + does not flag each_with_object when no transformation occurs + does not flag `each_with_object` when its argument is used in the value + flags _.map {...}.to_h when transform_values could be used + flags Hash[_.map{...}] when transform_values could be used + does not flag `_.map{...}.to_h` when its receiver is `zip` + does not flag `_.map{...}.to_h` when its receiver is `with_index` + with inline block + flags each_with_object when transform_values could be used + with multiline block + flags each_with_object when transform_values could be used + with safe navigation operator + flags each_with_object when transform_values could be used + +RuboCop::Cop::Security::IoMethods + when using `IO` receiver and string argument that starts with a pipe character (`" | command"`) + behaves like accepts + does not register an offense when using `IO.foreach(" | command") { |x| puts x }` + behaves like accepts + does not register an offense when using `IO.write(" | command", "hi")` + behaves like accepts + does not register an offense when using `IO.readlines(" | command")` + behaves like accepts + does not register an offense when using `IO.read(" | command")` + behaves like accepts + does not register an offense when using `IO.binwrite(" | command", "hi")` + when using `File` receiver + behaves like accepts + does not register an offense when using `File.foreach(path) { |x| puts x }` + behaves like accepts + does not register an offense when using `File.binread(path)` + behaves like accepts + does not register an offense when using `File.read(path)` + behaves like accepts + does not register an offense when using `File.readlines(path)` + behaves like accepts + does not register an offense when using `File.binwrite(path, "hi")` + when using `IO` receiver and variable argument + registers and corrects an offense when using `foreach` + behaves like offense + registers and corrects an offense when using `read` + behaves like offense + registers and corrects an offense when using `write` + behaves like offense + registers and corrects an offense when using `binread` + behaves like offense + registers and corrects an offense when using `binwrite` + behaves like offense + registers and corrects an offense when using `readlines` + when using `IO` receiver and string argument that starts with a pipe character (`"| command"`) + behaves like accepts + does not register an offense when using `IO.read("| command")` + behaves like accepts + does not register an offense when using `IO.readlines("| command")` + behaves like accepts + does not register an offense when using `IO.write("| command", "hi")` + behaves like accepts + does not register an offense when using `IO.foreach("| command") { |x| puts x }` + behaves like accepts + does not register an offense when using `IO.binwrite("| command", "hi")` + when using `IO` receiver and string argument + registers and corrects an offense when using `foreach` + behaves like offense + registers and corrects an offense when using `write` + behaves like offense + registers and corrects an offense when using `read` + behaves like offense + registers and corrects an offense when using `binwrite` + behaves like offense + registers and corrects an offense when using `binwrite` + behaves like offense + registers and corrects an offense when using `readlines` + when using no receiver + behaves like accepts + does not register an offense when using `read("command")` + behaves like accepts + does not register an offense when using `foreach("command") { |x| puts x }` + behaves like accepts + does not register an offense when using `readlines("command")` + behaves like accepts + does not register an offense when using `write("command", "hi")` + behaves like accepts + does not register an offense when using `binwrite("command", "hi")` + +RuboCop::Cop::Layout::AccessModifierIndentation + when EnforcedStyle is set to indent + registers an offense and corrects misaligned private in module + accepts methods with a body + accepts an empty class + accepts properly indented protected + registers an offense and corrects correct + opposite alignment + accepts properly indented private + registers an offense and corrects misaligned protected + registers an offense and corrects misaligned private in class defined with Class.new + registers an offense and corrects misaligned private + accepts properly indented private in module defined with Module.new + registers an offense and corrects misaligned private in module defined with Module.new + registers an offense and corrects misaligned private in a singleton class + registers an offense and corrects access modifiers in arbitrary blocks + registers an offense and corrects misaligned access modifiers in nested classes + accepts indented access modifiers with arguments in nested classes + registers an offense and corrects opposite + correct alignment + registers an offense and corrects misaligned module_function in module + when 4 spaces per indent level are used + accepts properly indented private + when indentation width is overridden for this cop only + accepts properly indented private + when EnforcedStyle is set to outdent + registers an offense and corrects private indented to method depth in module defined with Module.new + accepts module fn def indented to method depth in a module + registers an offense and corrects private indented to method depth in singleton class + accepts private with argument indented to method depth in module defined with Module.new + registers an offense and corrects module_function indented to method depth in a module + accepts private with argument indented to method depth in a class + accepts private with argument indented to method depth in singleton class + registers an offense and corrects private indented to method depth in class defined with Class.new + accepts private def indented to method depth in module defined with Module.new + accepts module fn with argument indented to method depth in a module + accepts protected indented to the containing class indent level + accepts private def indented to method depth in class defined with Class.new + accepts private def indented to method depth in a class + accepts private def indented to method depth in a module + accepts private indented to the containing class indent level + registers offense and corrects private indented to method depth in a class + accepts private with argument indented to method depth in class defined with Class.new + accepts private def indented to method depth in singleton class + registers an offense and corrects misaligned access modifiers in nested classes + registers an offense and corrects private indented to method depth in a module + accepts private with argument indented to method depth in a module + +RuboCop::Cop::Style::RedundantArgument + registers an offense and corrects when method called without parenthesis on literals + does not register an offense when method called with no receiver + registers an offense and corrects when method called on literals + does not register an offense when method called with more than one arguments + registers an offense and corrects when method called on variable + does not register an offense when method called with no arguments + works with double-quoted strings when configuration is single-quotes + registers an offense and corrects when method called without parenthesis on variable + does not register an offense when method called with different argument + non-builtin method + registers an offense and corrects with configured argument + does not register an offense with other argument + +RuboCop::Cop::Style::Encoding + registers an offense when encoding present on 2nd line after shebang + does not register an offense on a different magic comment type + does not register an offense when encoding present but not UTF-8 + does not register an offense when encoding is in the wrong place + does not register an offense when no encoding present + registers an offense and corrects the magic comment follows another magic comment + registers an offense and corrects if there are multiple encoding magic comments + registers an offense when encoding present and UTF-8 + does not register an offense when encoding is not at the top of the file + emacs comment + registers an offense for encoding + only removes encoding if there are other editor comments + vim comments + registers an offense and corrects + +RuboCop::Cop::Lint::OutOfRangeRegexpRef + does not register an offense regexp containing non literal + only registers an offense when the regexp is matched as a literal + does not register offense to a regexp with valid references for named captures + registers an offense when the regexp is matched with `===` + registers an offense when out of range references are used for non captures + registers an offense when out of range references are used for named captures + ignores `match` with no arguments + registers an offense when the regexp appears on the right hand side of `=~` + ignores calls to `match?` + registers an offense when references are used before any regexp + uses the maximum number of captures for when clauses with multiple conditions + ignores `match` with no receiver + only registers an offense for when clauses when the regexp is matched as a literal + registers an offense when out of range references are used inside a when clause + ignores regexp when clause conditions that contain interpolations + registers an offense when out of range references are used for mix of numbered and named captures + registers an offense when the regexp is matched with `match` + does not register offense to a regexp with valid references for a mix named and numbered captures + does not register offense to a regexp with valid references for numbered captures + does not register offense to a regexp with encoding option and valid references for numbered captures + does not register an offense when in range references are used inside a when clause + registers an offense when out of range references are used for numbered captures + matching with scan + does not register an offense when in range references are used + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + matching with start_with? + does not register an offense when in range references are used + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + matching with `grep` + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + matching with rindex + only registers an offense when the regexp is matched as a literal + registers an offense when out of range references are used + does not register an offense when in range references are used + matching with slice + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + matching with match + registers an offense when out of range references are used + does not register an offense when in range references are used + only registers an offense when the regexp is matched as a literal + matching with `[]` + does not register an offense when in range references are used + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + matching with sub! + registers an offense when out of range references are used + does not register an offense when in range references are used + only registers an offense when the regexp is matched as a literal + matching with gsub + only registers an offense when the regexp is matched as a literal + registers an offense when out of range references are used + does not register an offense when in range references are used + matching with slice! + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + registers an offense when out of range references are used + matching with gsub! + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + when calling a regexp method on a nth-ref node + does not register an offense when calling gsub on a valid nth-ref + registers an offense when calling gsub on an invalid nth-ref + registers an offense if the capturing groups have changed + matching with end_with? + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + registers an offense when out of range references are used + matching with sub + does not register an offense when in range references are used + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + matching with partition + only registers an offense when the regexp is matched as a literal + registers an offense when out of range references are used + does not register an offense when in range references are used + matching with index + registers an offense when out of range references are used + only registers an offense when the regexp is matched as a literal + does not register an offense when in range references are used + matching with rpartition + does not register an offense when in range references are used + only registers an offense when the regexp is matched as a literal + registers an offense when out of range references are used + when both the LHS and RHS use regexp + only considers the RHS regexp + +RuboCop::Cop::InternalAffairs::OffenseLocationKeyword + does not register an offense when the `loc` is on a child node + does not register an offense when the `loc` is on a different node + when `node.loc.selector` is passed + registers an offense if message argument is passed + registers an offense + +RuboCop::Cop::Style::OpenStructUse + when using OpenStruct + for ::OpenStruct + when inheriting from it via < + registers an offense + when inheriting from it via Class.new + registers an offense + when used in assignments + registers an offense + for OpenStruct + when inheriting from it via < + registers an offense + when used in assignments + registers an offense + when inheriting from it via Class.new + registers an offense + when not using OpenStruct + registers no offense + when using custom namespaced OpenStruct + when defined in custom namespace + when class + is expected to eq "module SomeNamespace\n class OpenStruct\n end\nend\n" + when module + is expected to eq "module SomeNamespace\n module OpenStruct\n end\nend\n" + when used in assignments + registers no offense + when inheriting from it + is expected to eq "class A < SomeNamespace::OpenStruct; end" + +RuboCop::Cop::Lint::AmbiguousAssignment + registers an offense when using `-` with `@@x` + does not register an offense when no mistype assignments + registers an offense when using `-` with `$x` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `+` with `@x` + registers an offense when using `*` with `x` + registers an offense when using `*` with `X` + registers an offense when using `+` with `@@x` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `-` with `@x` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `!` with `$x` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `-` with `x` + registers an offense when using `+` with `x` + registers an offense when using `!` with `@@x` + registers an offense when using `!` with `x` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `*` with `@@x` + registers an offense when using `+` with `$x` + registers an offense when using `!` with `X` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `!` with `@x` + registers an offense when using `*` with `$x` + registers an offense when using `*` with `@x` + does not register an offense when no mistype assignments + registers an offense when using `-` with `X` + does not register an offense when no mistype assignments + does not register an offense when no mistype assignments + registers an offense when using `+` with `X` + does not register an offense when no mistype assignments + +RuboCop::Cop::Style::SymbolArray + with non-default MinSize + does not autocorrect array of one symbol if MinSize > 1 + when EnforcedStyle is brackets + autocorrects an array starting with %i + registers an offense for array starting with %i + autocorrects an array has interpolations + registers an offense for empty array starting with %i + does not register an offense for arrays of symbols + autocorrects multiline %i array + when EnforcedStyle is percent + does not register an offense for array starting with %i + does not register an offense if symbol contains whitespace + doesn't break when a symbol contains ) + registers an offense for arrays of symbols + autocorrects arrays of symbols with embedded newlines and tabs + does not register an offense for array with non-syms + detects when the cop must be disabled to avoid offenses + detects right value for MinSize to use for --auto-gen-config + autocorrects arrays of one symbol + registers an offense in a non-ambiguous block context + uses %I when appropriate + autocorrects arrays of symbols with new line + when PreferredDelimiters is specified + autocorrects an array in multiple lines + autocorrects an array with delimiters + autocorrects an array using partial newlines + +RuboCop::Cop::Style::FileWrite + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+t') with heredoc + does not register an offense for the `File.open` with multiline write block when not writing to the block variable + registers an offense for and corrects `::File.open(filename, 'w').write(content)` + registers an offense for and corrects the `File.open` with inline write block (mode 'w+t') + registers an offense for and corrects the `File.open` with multiline write block (mode 'wb') with heredoc + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+b') with heredoc + registers an offense for and corrects `File.open(filename, 'w').write(content)` + does not register an offense when a splat argument is passed to `f.write` + registers an offense for and corrects `::File.open(filename, 'wt').write(content)` + registers an offense for and corrects the `File.open` with inline write block (mode 'w+') + registers an offense for and corrects `::File.open(filename, 'w+t').write(content)` + registers an offense for and corrects the `File.open` with multiline write block (mode 'w') + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+b') + registers an offense for and corrects the `File.open` with multiline write block (mode 'w') with heredoc + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+t') + registers an offense for and corrects `::File.open(filename, 'w+b').write(content)` + registers an offense for and corrects `::File.open(filename, 'wb').write(content)` + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+') with heredoc + registers an offense for and corrects the `File.open` with multiline write block (mode 'wt') with heredoc + registers an offense for and corrects the `File.open` with inline write block (mode 'wb') + registers an offense for and corrects the `File.open` with inline write block (mode 'w') + registers an offense for and corrects the `File.open` with multiline write block (mode 'wt') + registers an offense for and corrects `File.open(filename, 'w+').write(content)` + registers an offense for and corrects `::File.open(filename, 'w+').write(content)` + registers an offense for and corrects the `File.open` with multiline write block (mode 'wb') + registers an offense for and corrects `File.open(filename, 'wt').write(content)` + registers an offense for and corrects `File.open(filename, 'w+t').write(content)` + registers an offense for and corrects the `File.open` with multiline write block (mode 'w+') + registers an offense for and corrects `File.open(filename, 'w+b').write(content)` + registers an offense for and corrects the `File.open` with inline write block (mode 'w+b') + registers an offense for and corrects the `File.open` with inline write block (mode 'wt') + registers an offense for and corrects `File.open(filename, 'wb').write(content)` + +RuboCop::Cop::Layout::MultilineHashKeyLineBreaks + with line break after opening bracket + registers an offense and corrects when key starts on same line as another + when on different lines than brackets but keys on one + does not add any offenses + when on all keys on one line different than brackets + does not add any offenses + when key starts on same line as another with rockets + adds an offense + without line break after opening bracket + registers an offense and corrects nested hashes + registers an offense and corrects when key starts on same line as another + when on same line + does not add any offenses + +RuboCop::Cop::Lint::ShadowingOuterLocalVariable + when a block local variable has same name as an outer scope variablewith different branches of same `unless` condition node + does not register an offense + when a block local variable has same name as an outer scope variablewith same branches of same `case` condition node + registers an offense + when multiple block arguments have same name "_" + does not register an offense + when a block local variable has same name as an outer scope variablewith same branches of same `if` condition node not in the method definition + registers an offense + when a block local variable has same name as an outer scope variablewith different branches of same `case` condition node + does not register an offense + when a block block argument has same name as an outer scope variable + registers an offense + when a block local variable has same name as an outer scope variable + registers an offense + when a block local variable has same name as an outer scope variablewith same branches of same `unless` condition node + registers an offense + when a block local variable has same name as an outer scope variablewith different branches of same `if` condition node + does not register an offense + when the same variable name as a block variable is used in return value assignment of `if` + does not register an offense + when multiple block arguments have a same name starts with "_" + does not register an offense + when an outer scope variable is referenced in a block + does not register an offense + when an outer scope variable is reassigned in a block + does not register an offense + when a block argument has same name as an outer scope variable + registers an offense + when a block local variable has same name as an outer scope variablewith same branches of same nested `if` condition node + registers an offense + when a block argument has a same name starts with "_" as an outer scope variable + does not register an offense + when a block argument has same name "_" as outer scope variable "_" + does not register an offense + when a method argument has same name as an outer scope variable + does not register an offense + when a block argument has different name with outer scope variables + does not register an offense + when a block local variable has same name as an outer scope variablewith same branches of same `if` condition node + registers an offense + with Ractor.new + does not register an offense + when a splat block argument has same name as an outer scope variable + registers an offense + +RuboCop::Cop::Layout::HeredocIndentation + quoted by + accepts for include empty lines + registers an offense for not indented enough with whitespace line + displays message to use `<<~` instead of `<<-` + registers an offense for too deep indented with whitespace line + accepts for an empty line + displays message to use `<<~` instead of `<<` + accepts for indented, but with `-` + registers an offense for first line minus-level indented, with `-` + registers an offense for not indented, without `~` + does not register an offense when not indented but with whitespace, with `-` + registers an offense for too deep indented with empty line + registers an offense for too deep indented + registers an offense for not indented, with `~` + registers an offense for minus level indented + registers an offense for not indented enough with empty line + accepts for not indented but with whitespace + accepts for indented, but without `~` + accepts for indented, with `~` + registers an offense for not indented + when Layout/LineLength is configured + accepts for long heredoc + quoted by ' + registers an offense for not indented + registers an offense for not indented enough with whitespace line + accepts for indented, but with `-` + registers an offense for first line minus-level indented, with `-` + registers an offense for too deep indented with empty line + accepts for not indented but with whitespace + does not register an offense when not indented but with whitespace, with `-` + registers an offense for not indented, without `~` + displays message to use `<<~` instead of `<<-` + registers an offense for not indented enough with empty line + registers an offense for too deep indented with whitespace line + registers an offense for too deep indented + displays message to use `<<~` instead of `<<` + accepts for indented, with `~` + registers an offense for minus level indented + accepts for indented, but without `~` + registers an offense for not indented, with `~` + accepts for include empty lines + accepts for an empty line + when Layout/LineLength is configured + accepts for long heredoc + quoted by ` + displays message to use `<<~` instead of `<<-` + accepts for include empty lines + registers an offense for not indented enough with whitespace line + registers an offense for too deep indented with whitespace line + accepts for indented, with `~` + registers an offense for too deep indented with empty line + registers an offense for not indented enough with empty line + registers an offense for not indented + displays message to use `<<~` instead of `<<` + accepts for an empty line + accepts for indented, but with `-` + accepts for not indented but with whitespace + registers an offense for not indented, with `~` + registers an offense for minus level indented + registers an offense for too deep indented + registers an offense for not indented, without `~` + registers an offense for first line minus-level indented, with `-` + does not register an offense when not indented but with whitespace, with `-` + accepts for indented, but without `~` + when Layout/LineLength is configured + accepts for long heredoc + quoted by " + registers an offense for too deep indented with empty line + registers an offense for too deep indented with whitespace line + accepts for include empty lines + registers an offense for not indented enough with whitespace line + does not register an offense when not indented but with whitespace, with `-` + registers an offense for minus level indented + displays message to use `<<~` instead of `<<-` + registers an offense for not indented, with `~` + accepts for an empty line + registers an offense for first line minus-level indented, with `-` + accepts for indented, but with `-` + accepts for indented, but without `~` + registers an offense for not indented, without `~` + registers an offense for not indented + accepts for not indented but with whitespace + registers an offense for not indented enough with empty line + displays message to use `<<~` instead of `<<` + registers an offense for too deep indented + accepts for indented, with `~` + when Layout/LineLength is configured + accepts for long heredoc + +RuboCop::Cop::Style::TrailingCommaInBlockArgs + curly brace block format + preserves semicolons in block/local variables + does not register an offense when no arguments are present + registers an offense when a trailing comma is not needed + ignores commas in default argument strings + does not register an offense when a trailing comma is required + does not register an offense when more than one argument is present with no trailing comma + does not register an offense for default arguments + does not register an offense for keyword arguments + when `->` has multiple arguments + does not register an offense + do/end block format + registers an offense when a trailing comma is not needed + does not register an offense for default arguments + does not register an offense when more than one argument is present with no trailing comma + does not register an offense when a trailing comma is required + does not register an offense for an empty block + does not register an offense when no arguments are present + preserves semicolons in block/local variables + does not register an offense for keyword arguments + ignores commas in default argument strings + when `lambda` has multiple arguments + registers an offense and corrects when a trailing comma isn't needed + does not register an offense when more than one argument is present with no trailing comma + +RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords + accepts `rescue` and `end` are on the same line + with complex begin-end - registers many offenses + accepts `def` and `rescue` are on the same line + accepts last `rescue` and `end` are on the same line + accepts `begin` and `rescue` are on the same line + accepts empty method definition + registers an offense for above rescue keyword with a blank + registers an offense for rescue section ending with a blank + with complex method definition - registers many offenses + accepts empty begin + registers an offense for rescue section ending for method definition a blank + accepts no empty line + accepts empty lines around begin body + registers an offense for rescue section starting with a blank + +RuboCop::Cop::Style::BarePercentLiterals + when EnforcedStyle is bare_percent + and strings are dynamic + accepts "" + accepts '' + accepts %() + accepts heredoc + accepts __FILE__ + accepts %q + registers an offense for %Q() + accepts "" string with interpolation + accepts regular expressions + and strings are static + accepts %q + accepts heredoc + accepts %() + accepts __FILE__ + accepts regular expressions + accepts '' + accepts "" + accepts "" string with interpolation + registers an offense for %Q() + when EnforcedStyle is percent_q + and strings are static + accepts __FILE__ + accepts "" + accepts heredoc + accepts %Q() + accepts '' + accepts %q + accepts "" string with interpolation + accepts regular expressions + registers an offense for %() + and strings are dynamic + accepts %Q() + accepts regular expressions + accepts "" string with interpolation + registers an offense for %() + accepts __FILE__ + accepts "" + accepts heredoc + accepts %q + accepts '' + +RuboCop::Cop::Style::EndBlock + does not report offenses for other blocks + reports an offense and corrects END block + +RuboCop::Cop::Lint::SuppressedException + with AllowComments set to true + registers an offense for empty rescue on single line with a comment after it + does not register an offense for empty rescue with comment + when empty rescue for `def` + does not register an offense for empty rescue with comment + registers an offense for empty rescue without comment + Ruby 2.5 or higher + when empty rescue for `do` block + does not register an offense for empty rescue with comment + registers an offense for empty rescue without comment + Ruby 2.7 or higher + when empty rescue for `do` block with a numbered parameter + registers an offense for empty rescue without comment + does not register an offense for empty rescue with comment + when empty rescue for `defs` + does not register an offense for empty rescue with comment + registers an offense for empty rescue without comment + with AllowComments set to false + does not register an offense for rescue with body + registers an offense for empty rescue block + Ruby 2.5 or higher + when empty rescue for `do` block + registers an offense for empty rescue without comment + registers an offense for empty rescue with comment + when empty rescue for `def` + registers an offense for empty rescue with comment + registers an offense for empty rescue without comment + with AllowNil set to false + registers an offense for inline nil rescue + registers an offense for rescue block with nil + with AllowNil set to true + does not register an offense for inline nil rescue + does not register an offense for rescue block with nil + when empty rescue for defs + registers an offense for empty rescue without comment + registers an offense for empty rescue with comment + +RuboCop::Cop::Lint::ShadowedArgument + method argument shadowing + when a single argument is shadowed + registers an offense + when a splat argument is shadowed + registers an offense + and shadowed within a conditional + registers an offense without specifying where the reassignment took place + and the conditional is nested within a conditional + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and was used before shadowing + accepts + and the conditional is nested within a lambda + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and the argument was not shadowed outside the conditional + accepts + and the conditional occurs after the reassignment + registers an offense + when zsuper is used + registers an offense + when IgnoreImplicitReferences config option is set to true + accepts + when argument was shadowed by zsuper + does not register an offense + when argument was shadowed by zsuper + registers an offense + when argument was used in shorthand assignment + does not register an offense + and shadowed within a block + registers an offense without specifying where the reassignment took place + and was used before shadowing + accepts + and the block is nested within a block + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and the block occurs after the reassignment + registers an offense + and the argument was not shadowed outside the block + accepts + and the block is nested within a conditional + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + when reassigning to splat variable + does not register an offense + and the argument is not used + accepts + when binding is used + registers an offense + when IgnoreImplicitReferences config option is set to true + accepts + when multiple arguments are shadowed + and one of them shadowed within a lambda while another is shadowed outside + registers an offense + block argument shadowing + when multiple arguments are shadowed + and one of them shadowed within a lambda while another is shadowed outside + registers an offense + when a single argument is shadowed + registers an offense + when binding is used + registers an offense + when IgnoreImplicitReferences config option is set to true + accepts + when zsuper is used + accepts + and shadowed within a block + registers an offense without specifying where the reassignment took place + and the block is nested within a block + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and the argument was not shadowed outside the block + accepts + and was used before shadowing + accepts + and the block is nested within a conditional + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and the block occurs after the reassignment + registers an offense + and the argument is not used + accepts + and shadowed within a conditional + registers an offense without specifying where the reassignment took place + and the conditional is nested within a lambda + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and the argument was not shadowed outside the conditional + accepts + and the conditional occurs after the reassignment + registers an offense + and the conditional is nested within a conditional + registers an offense without specifying where the reassignment took place + and the argument was used before shadowing + accepts + and was used before shadowing + accepts + when a block local variable is assigned but no argument is shadowed + accepts + +RuboCop::Cop::Naming::VariableNumber + when CheckSymbols is false + does not register an offense for snake case numbering in symbol + when AllowedIdentifiers is set + does not register an offense for a global variable name that is allowed + does not register an offense for a method name that is allowed + does not register an offense for a class variable name that is allowed + does not register an offense for a symbol that is allowed + does not register an offense for a instance variable name that is allowed + does not register an offense for a local variable name that is allowed + when configured for normal + registers an offense for snake case numbering in method camel case parameter + registers an offense for snake case numbering in symbol + registers an offense for snake case numbering in method name + registers an offense for snake case numbering in a global variable name + does not register an offense for normal case numbering in symbol + registers an offense for snake case numbering in method parameter + behaves like accepts + accepts @__foo__ in normalcase + behaves like accepts + accepts local_ in normalcase + behaves like accepts + accepts local1 in normalcase + behaves like offense + registers an offense for localFOO_1 in normalcase + behaves like accepts + accepts user_1_id in normalcase + behaves like offense + registers an offense for @@local_1 in normalcase + behaves like accepts + accepts target_u2f_device in normalcase + behaves like offense + registers an offense for sha_256 in normalcase + behaves like offense + registers an offense for _myLocal_1 in normalcase + behaves like accepts + accepts sha256 in normalcase + behaves like accepts + accepts _1 in normalcase + behaves like offense + registers an offense for local_1 in normalcase + behaves like accepts + accepts snake_case in normalcase + behaves like accepts + accepts emparejó in normalcase + behaves like accepts + accepts _ in normalcase + behaves like accepts integer symbols + accepts integer symbol + accepts integer symbol array literal + behaves like offense_array + registers an offense for ["a_1", "a2"] in normalcase + behaves like accepts + accepts foo10_bar in normalcase + behaves like offense + registers an offense for myAttribute_1 in normalcase + behaves like offense + registers an offense for local_FOO_1 in normalcase + behaves like accepts + accepts user1_id in normalcase + behaves like accepts + accepts _foo in normalcase + behaves like offense + registers an offense for @local_1 in normalcase + behaves like accepts + accepts @foo in normalcase + behaves like accepts + accepts localFOO1 in normalcase + behaves like offense + registers an offense for @myAttribute_1 in normalcase + when configured for non integer + registers an offense for normal case numbering in method name + registers an offense for snake case numbering in method name + registers an offense for snake case numbering in method parameter + registers an offense for snake case numbering in method camel case parameter + registers an offense for normal case numbering in symbol + registers an offense for snake case numbering in symbol + registers an offense for normal case numbering in method parameter + registers an offense for normal case numbering in method camel case parameter + behaves like offense + registers an offense for @local1 in non_integer + behaves like accepts + accepts local_ in non_integer + behaves like offense_array + registers an offense for ["a_1", "aone"] in non_integer + behaves like offense + registers an offense for myAttribute1 in non_integer + behaves like accepts + accepts localone in non_integer + behaves like accepts + accepts @@foo in non_integer + behaves like accepts integer symbols + accepts integer symbol + accepts integer symbol array literal + behaves like offense + registers an offense for myAttribute_1 in non_integer + behaves like offense + registers an offense for _myLocal_1 in non_integer + behaves like accepts + accepts @foo in non_integer + behaves like accepts + accepts _foo in non_integer + behaves like accepts + accepts _1 in non_integer + behaves like offense + registers an offense for @myAttribute_1 in non_integer + behaves like offense + registers an offense for local1 in non_integer + behaves like offense + registers an offense for @myAttribute1 in non_integer + behaves like accepts + accepts local_one in non_integer + behaves like accepts + accepts emparejó in non_integer + behaves like accepts + accepts fooBar in non_integer + behaves like offense + registers an offense for _myLocal1 in non_integer + behaves like offense + registers an offense for @local_1 in non_integer + behaves like offense + registers an offense for local_1 in non_integer + behaves like accepts + accepts _ in non_integer + behaves like accepts + accepts @__foo__ in non_integer + when AllowedPatterns is set + does not register an offense for a class variable name that matches an allowed pattern + does not register an offense for a symbol that matches an allowed pattern + does not register an offense for a instance variable name that matches an allowed pattern + registers an offense for a class variable name that does not match an allowed pattern + registers an offense for a method name that does not match an allowed pattern + registers an offense for a global variable name that does not match an allowed pattern + registers an offense for a symbol that does not match an allowed pattern + does not register an offense for a local variable name that matches an allowed pattern + registers an offense for a instance variable name that does not match an allowed pattern + does not register an offense for a global variable name that matches an allowed pattern + does not register an offense for a method name that matches an allowed pattern + registers an offense for a local variable name that does not match an allowed pattern + when CheckMethodNames is false + does not register an offense for snake case numbering in method name + when configured for snake_case + registers an offense for normal case numbering in a global variable name + does not register an offense for snake case numbering in symbol + registers an offense for normal case numbering in method parameter + registers an offense for normal case numbering in method name + registers an offense for normal case numbering in method camel case parameter + registers an offense for normal case numbering in symbol + behaves like accepts + accepts _ in snake_case + behaves like accepts + accepts local_ in snake_case + behaves like accepts + accepts local_123 in snake_case + behaves like accepts + accepts @foo in snake_case + behaves like accepts + accepts local_1 in snake_case + behaves like offense + registers an offense for @local1 in snake_case + behaves like offense + registers an offense for camelCase1 in snake_case + behaves like offense + registers an offense for local1 in snake_case + behaves like accepts + accepts _1 in snake_case + behaves like accepts + accepts emparejó in snake_case + behaves like accepts + accepts a_1_b_1 in snake_case + behaves like offense + registers an offense for @camelCase1 in snake_case + behaves like offense + registers an offense for _unused1 in snake_case + behaves like offense + registers an offense for @@local1 in snake_case + behaves like offense_array + registers an offense for ["a1", "a_2"] in snake_case + behaves like accepts + accepts a_1_b in snake_case + behaves like accepts + accepts local_12 in snake_case + behaves like accepts integer symbols + accepts integer symbol array literal + accepts integer symbol + behaves like accepts + accepts @__foo__ in snake_case + behaves like accepts + accepts aB_1 in snake_case + behaves like accepts + accepts _foo in snake_case + behaves like offense + registers an offense for aB1 in snake_case + +RuboCop::Cop::Style::ZeroLengthPredicate + when name of the variable is `size` or `length` + accepts inequality check + accepts comparison + accepts equality check + with collection variables + registers an offense for `0 == collection.size` + registers an offense for `0 != collection.size` + registers an offense for `collection.size != 0` + registers an offense for `collection.size == 0` + when inspecting a File::Stat object + does not register an offense + does not register an offense with ::File + with hashes + registers an offense for `0 != hash.size` + registers an offense for `hash.size == 0` + registers an offense for `0 == hash.size + registers an offense for `hash.size != 0` + with strings + registers an offense for `string.size != 0` + registers an offense for `string.size == 0` + registers an offense for `0 == string.size` + registers an offense for `0 != string.size` + when inspecting a StringIO object + when initialized with a string + does not register an offense with top-level ::StringIO + does not register an offense + when initialized without arguments + does not register an offense with top-level ::StringIO + does not register an offense + when inspecting a Tempfile object + does not register an offense + does not register an offense with top-level ::Tempfile + with arrays + registers an offense for `0 != array.size` + registers an offense for `1 > array.size` + registers an offense for `0 < array.length + registers an offense for `0 == array.length` + registers an offense for `array.length > 0` + registers an offense for `array.length == 0` + registers an offense for `0 == array.size` + registers an offense for `1 > array.length` + registers an offense for `array.size == 0` + registers an offense for `array.size > 0` + registers an offense for `array.length != 0` + registers an offense for `array.size != 0` + registers an offense for `array.size < 1` + registers an offense for `0 < array.size` + registers an offense for `0 != array.length` + registers an offense for `array.length < 1` + +RuboCop::Cop::Layout::RedundantLineBreak + when InspectBlocks is false + when Layout/SingleLineBlockChain is enabled + accepts a method call chained onto a single line block + when Layout/SingleLineBlockChain is disabled + reports an offense for a method call chained onto a single line block + for an expression that does not fit on a single line + accepts a method call on a multiple lines + with a longer max line length + accepts method call with a do keyword that would just surpass the max line length + accepts a complex method call on a multiple lines + accepts an assignment containing a method definition + registers an offense for a method call with a do keyword that is just under the max line length + accepts a method call followed by binary operations that are too long taken together + accepts an assignment containing a heredoc + for a block + accepts when it is difficult to convert to single line + for an expression that fits on a single line + accepts an assignment containing a case expression + accepts a binary expression containing an if expression + registers an offense for a method call with a double quoted split string without parentheses + accepts an assignment containing a begin-end expression + accepts a method call with a block + registers an offense for a method call on multiple lines inside a block + registers an offense for a method call on multiple lines + registers an offense for a method call with a split operation + registers an offense for a method call with a single quoted split string + registers an offense for a method call with a double quoted split string in parentheses + registers an offense for a method call with a double and single quoted split string + accepts a method call on multiple lines if there are comments on them + accepts an assignment containing an if expression + registers an offense for a method call on multiple lines with backslash + registers an offense for a method call as right hand side of an assignment + accepts a method call on a single line + method chains + properly corrects a method chain on multiple lines + registers an offense and corrects with a arguments on multiple lines + registers an offense and corrects with a string argument on multiple lines + does not register an offense with a heredoc argument + with LineLength Max 100 + registers an offense for a method without parentheses on multiple lines + for a block + accepts when the method call has no arguments + accepts when the method call has parentheses + when Layout/SingleLineBlockChain is disabled + accepts a multiline block without a chained method call + accepts a method call chained onto a multiline block + when Layout/SingleLineBlockChain is enabled + accepts a multiline block without a chained method call + when InspectBlocks is true + when Layout/SingleLineBlockChain is disabled + reports an offense for a method call chained onto a single line block + for an expression that fits on a single line + accepts a binary expression containing an if expression + registers an offense for a method call as right hand side of an assignment + accepts a method call on multiple lines if there are comments on them + registers an offense for a method call on multiple lines inside a block + registers an offense for a method call on multiple lines with backslash + registers an offense for a method call with a single quoted split string + accepts a method call on a single line + accepts an assignment containing a begin-end expression + registers an offense for a method call with a split operation + registers an offense for a method call on multiple lines + accepts an assignment containing an if expression + registers an offense for a method call with a double quoted split string without parentheses + registers an offense for a method call with a double and single quoted split string + accepts a method call with a block + registers an offense for a method call with a double quoted split string in parentheses + accepts an assignment containing a case expression + with LineLength Max 100 + registers an offense for a method without parentheses on multiple lines + method chains + does not register an offense with a heredoc argument + registers an offense and corrects with a string argument on multiple lines + registers an offense and corrects with a arguments on multiple lines + properly corrects a method chain on multiple lines + when Layout/SingleLineBlockChain is enabled + accepts a method call chained onto a single line block + for a block + registers an offense when the method call has parentheses + registers an offense when the method call has no arguments + when Layout/SingleLineBlockChain is disabled + reports an offense for a method call chained onto a multiline block + reports an offense for a multiline block without a chained method call + when Layout/SingleLineBlockChain is enabled + reports an offense for a multiline block without a chained method call + for an expression that does not fit on a single line + accepts a method call on a multiple lines + with a longer max line length + accepts a complex method call on a multiple lines + registers an offense for a method call with a do keyword that is just under the max line length + accepts an assignment containing a method definition + accepts an assignment containing a heredoc + accepts a method call followed by binary operations that are too long taken together + accepts method call with a do keyword that would just surpass the max line length + for a block + accepts when it is difficult to convert to single line + +RuboCop::Cop::Layout::TrailingWhitespace + is not fooled by __END__ within a documentation comment + registers an offense for a tab in a heredoc + registers an offense for a line ending with tab + autocorrects unwanted space + registers an offense for a blank line with space + registers an offense for trailing whitespace in a heredoc string + registers an offense for a line ending with space + registers offenses before __END__ but not after + is not fooled by heredoc containing __END__ + accepts a line without trailing whitespace + is not fooled by heredoc containing __END__ within a doc comment + when `AllowInHeredoc` is set to false + corrects by removing trailing whitespace used for indentation in a heredoc string + corrects safely trailing whitespace in a heredoc string + does not correct trailing whitespace in a static heredoc string + corrects a whitespace line in a heredoc string that is longer than the indentation + when `AllowInHeredoc` is set to true + registers an offense for trailing whitespace at the heredoc begin + accepts trailing whitespace in a heredoc string + +RuboCop::Cop::Style::TrivialAccessors + accepts writer with different ivar name + registers an offense on reader with `private` + accepts reader nested within an instance_eval call + registers an offense on reader with braces + accepts expressions within reader + accepts splats + accepts reader nested within a module + registers an offense on one-liner reader + accepts reader with different ivar name + registers an offense on instance writer + accepts an initialize method looking like a writer + accepts writer using top level + accepts blocks + accepts non-trivial reader + accepts non-trivial writer + flags a reader inside a class, inside an instance_eval call + registers an offense on class writer + registers an offense on one-liner writer + registers an offense on class reader + accepts writer nested within an instance_eval call + registers an offense on instance reader + accepts writer nested within a module + accepts writer in a module + accepts reader using top level + accepts expressions within writer + does not register an offense on DSL-style writer + registers an offense on writer without braces + ignore class methods + accepts class reader + accepts class writer + allow predicates + accepts predicate-like reader + with allowed methods + accepts allowed writer + accepts allowed reader + with AllowPredicates: false + accepts allowed predicate + exact name match disabled + registers an offense when names mismatch in writer + registers an offense when names mismatch in reader + disallow predicates + does not accept predicate-like reader + with DSL denied + registers an offense on DSL-style writer + +RuboCop::Cop::Style::RedundantFreeze + allows .freeze on method call + behaves like mutable objects + allows ('a' + 'b') with freeze + behaves like immutable objects + registers an offense for frozen (a > b) + behaves like immutable objects + registers an offense for frozen (1 + 2) + behaves like immutable objects + registers an offense for frozen :"" + behaves like immutable objects + registers an offense for frozen [1, 2, 3].size + behaves like mutable objects + allows 'str' with freeze + behaves like mutable objects + allows ([42] * 42) with freeze + behaves like mutable objects + allows "top#{1 + 2}" with freeze + behaves like mutable objects + allows ::ENV['foo'] with freeze + behaves like mutable objects + allows (a + b) with freeze + behaves like immutable objects + registers an offense for frozen 1.5 + behaves like immutable objects + registers an offense for frozen (2 > 1) + when the receiver is a string literal + Regexp and Range literals + Ruby 2.7 or lower + behaves like mutable objects + allows (1...5) with freeze + behaves like mutable objects + allows /./ with freeze + behaves like mutable objects + allows (1..5) with freeze + Ruby 3.0 or higher + behaves like immutable objects + registers an offense for frozen /./ + behaves like immutable objects + registers an offense for frozen (1...5) + behaves like immutable objects + registers an offense for frozen (1..5) + Ruby 3.0 or higher + when the frozen string literal comment is false + behaves like mutable objects + allows "#{a}" with freeze + when the frozen string literal comment is missing + behaves like mutable objects + allows "#{a}" with freeze + when the frozen string literal comment is true + behaves like mutable objects + allows "#{a}" with freeze + Ruby 2.7 or lower + when the frozen string literal comment is true + behaves like immutable objects + registers an offense for frozen "#{a}" + when the frozen string literal comment is false + behaves like mutable objects + allows "#{a}" with freeze + when the frozen string literal comment is missing + behaves like mutable objects + allows "#{a}" with freeze + behaves like mutable objects + allows [1, 2, 3] with freeze + behaves like mutable objects + allows { a: 1, b: 2 } with freeze + behaves like immutable objects + registers an offense for frozen 'foo'.count + behaves like immutable objects + registers an offense for frozen 1 + behaves like immutable objects + registers an offense for frozen :sym + behaves like immutable objects + registers an offense for frozen ('a' > 'b') + behaves like mutable objects + allows ENV['foo'] with freeze + behaves like mutable objects + allows ('a' * 20) with freeze + +RuboCop::Cop::Style::IfWithBooleanLiteralBranches + when condition is a method that does not known whether to return boolean value + does not register an offense when using `if condition` with boolean literal branches + does not register an offense when using `if condition` with opposite boolean literal branches + does not register an offense when using `unless condition` with boolean literal branches + does not register an offense when using `unless condition` with opposite boolean literal branches + when condition is a comparison method + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `if foo == bar` with boolean literal branches + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + does not register an offense when using a branch that is not boolean literal + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + registers and corrects an offense when using ternary operator with boolean literal branches + does not register an offense when using a branch that is not boolean literal + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `if` with boolean literal branches directly under `def` + registers and corrects an offense when using `if foo == bar` with boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `unless foo == bar` with opposite boolean literal branches + registers and corrects an offense when using ternary operator with boolean literal branches + registers and corrects an offense when using opposite ternary operator with boolean literal branches + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `if foo == bar` with opposite boolean literal branches + registers and corrects an offense when using `unless foo == bar` with boolean literal branches + when condition is a logical operator and operands do not known whether to return boolean value + does not register an offense when using `unless foo || bar` with opposite boolean literal branches + does not register an offense when using `unless foo || bar` with boolean literal branches + does not register an offense when using `if foo || bar` with boolean literal branches + does not register an offense when using `if foo && bar` with opposite boolean literal branches + does not register an offense when using `if foo && bar` with boolean literal branches + does not register an offense when using `if foo || bar` with opposite boolean literal branches + does not register an offense when using `unless foo && bar` with boolean literal branches + does not register an offense when using `unless foo && bar` with opposite boolean literal branches + when using `elsif` with boolean literal branches + does not register an offense when using multiple `elsif` with boolean literal branches + registers and corrects an offense when using single `elsif` with boolean literal branches + when condition is a logical operator and all operands are predicate methods + registers and corrects an offense when using `if foo? && bar?` with boolean literal branches + registers and corrects an offense when using `unless foo? || bar?` with boolean literal branches + registers and corrects an offense when using `unless foo? || bar?` with opposite boolean literal branches + registers and corrects an offense when using `if foo? && bar? || baz?` with boolean literal branches + registers and corrects an offense when using `if foo? && bar? && baz?` with boolean literal branches + registers and corrects an offense when using `if foo? && bar?` with opposite boolean literal branches + when complex condition + registers and corrects an offense when using `if foo? || (bar && baz)?` with boolean literal branches + does not register an offense when using `if foo? || bar || baz?` with boolean literal branches + registers and corrects an offense when using `if foo? && bar && baz?` with boolean literal branches + registers and corrects an offense when using `if foo? || bar && baz?` with boolean literal branches + does not register an offense when using `if (foo? && bar) || baz?` with boolean literal branches + register and corrects an offense when using `if (foo? || bar) && baz?` with boolean literal branches + does not register an offense when using `if foo? && bar || baz?` with boolean literal branches + does not register an offense when using `if foo? && (bar || baz)?` with boolean literal branches + when condition is a predicate method + registers and corrects an offense when using `unless foo.do_something?` with boolean literal branches + registers and corrects an offense when using `elsif foo.do_something?` with opposite boolean literal branches + registers and corrects an offense when using `if foo.do_something?` with opposite boolean literal branches + registers and corrects an offense when using `elsif foo.do_something?` with boolean literal branches + registers and corrects an offense when using `unless foo.do_something?` with opposite boolean literal branches + registers and corrects an offense when using `if foo.do_something?` with boolean literal branches + when double negative is used in condition + registers and corrects an offense when using `if !!condition` with opposite boolean literal branches + registers and corrects an offense when using `if !!condition` with boolean literal branches + when `AllowedMethods: nonzero?` + does not register an offense when using `nonzero?` + +RuboCop::Cop::Lint::UselessSetterCall + is not confused by operators ending with = + accepts exception assignments without exploding + when a lvar contains a local object instantiated with literal + registers an offense and corrects for the setter call on the lvar + when a lvar declared as an argument is no longer the passed object at the end of the method + registers an offense and corrects for the setter call on the lvar + when a lvar possibly contains an object passed as argument by logical-operator-assignment at the end of the method + accepts the setter call on the lvar + with method ending with setter call on ivar + accepts + when a lvar does not contain any object passed as argument with multiple-assignment at the end of the method + registers an offense and corrects + when a lvar contains a non-local object returned by a method + accepts + when a lvar contains an object passed as argument at the end of the method + accepts the setter call on the lvar + with method ending with square bracket setter on local object + registers an offense and corrects + when a lvar contains an object passed as argument by multiple-assignment at the end of the method + accepts the setter call on the lvar + when a lvar does not contain any object passed as argument by binary-operator-assignment at the end of the method + registers an offense and corrects + with method ending with ivar assignment + accepts + with method ending with setter call on local object + registers an offense and corrects + with method ending with setter call on argument + accepts + with singleton method ending with setter call on local object + registers an offense and corrects + +RuboCop::Cop::Layout::SpaceInsideBlockBraces + registers an offense and corrects right brace without inner space + register offenses and correct both braces without inner space + accepts braces surrounded by spaces + registers an offense and corrects left brace without inner space + accepts left brace without outer space + registers an offense and corrects both left and right brace without inner space after success + with invalid value for EnforcedStyleForEmptyBraces + fails with an error + with space inside empty braces not allowed + accepts empty braces with comment and line break inside + accepts empty braces with no space inside + accepts braces with something inside + accepts braces that are not empty + registers an offense and corrects empty braces with space inside + accepts empty braces with line break inside + accepts multiline braces with content + configured with no_space + registers an offense and corrects left brace with inner space + accepts braces without spaces inside + registers an offense and corrects right brace with inner space + registers an offense and corrects both left and right brace with inner space after success + accepts left brace without outer space + with passed in parameters + and space before block parameters not allowed + registers an offense when braces are not aligned in multiline block with bracket + registers an offense when braces are not aligned in multiline block + accepts new lambda syntax + accepts when braces are aligned in multiline block with bracket + registers an offense and corrects left brace with inner space + accepts when braces are aligned in multiline block + and space before block parameters allowed + accepts left brace with inner space + registers an offense and corrects left brace without inner space + accepts new lambda syntax + with passed in parameters + accepts new lambda syntax + and BlockDelimiters cop enabled + registers an offense and corrects multi-line blocks + registers an offense and corrects for single-line blocks + and space before block parameters not allowed + accepts new lambda syntax + registers an offense and corrects left brace with inner space + accepts left brace without inner space + for single-line blocks + accepts left brace with inner space + registers an offense and corrects left brace without inner space + for multi-line blocks + accepts left brace with inner space + registers an offense and corrects left brace without inner space + Ruby >= 2.7 + registers an offense for numblocks without inner space + with space inside empty braces allowed + accepts empty braces with space inside + registers an offense and corrects empty braces with no space inside + +RuboCop::Cop::Lint::SafeNavigationWithEmpty + outside a conditional + registers no offense + in a conditional + registers an offense and corrects on `&.empty?` + does not register an offense on `.empty?` + +RuboCop::Cop::Lint::UnreachableCode + accepts `exit!` as the final expression + accepts `redo` as the final expression + accepts `fail` is in `if` branch only + registers an offense for `raise` in all `case` branches + registers an offense for `abort` in all `if` branches with other expressions + registers an offense for `return` in all `if` branches with other expressions + accepts code with conditional `retry` + registers an offense for `exit` in all `if` branches + registers an offense for `next` in `begin` + accepts code with conditional `next` + registers an offense for `return` in `begin` + accepts `retry` is in `else` branch only + accepts `abort` is in `case` branch without else + accepts `redo` is in `if` branch only + registers an offense for `throw` in all `if` and `elsif` branches + accepts `exit!` is in `if` branch only + registers an offense for `exit!` in all `if` branches with other expressions + registers an offense for `raise` in all `if` branches with other expressions + registers an offense for `throw` in all `case` branches + registers an offense for `redo` before other statements + accepts `exit` as the final expression + accepts `fail` is in `else` branch only + accepts `raise` is in `case` branch without else + accepts `next` is in `if` branch only + accepts `fail` is in `if`, and without `else` + accepts `abort` as the final expression + registers an offense for `raise` before other statements + accepts `abort` is in `else` branch only + registers an offense for `break` in all `if` and `elsif` branches + accepts `retry` is in all `if` branches + accepts `break` is in `else` branch only + accepts code with conditional `abort` + accepts `abort` is in all `if` branches + registers an offense for `return` before other statements + accepts `fail` is not in `elsif` branch + accepts `return` is in `if`, and without `else` + registers an offense for `retry` before other statements + accepts `exit` is in `else` branch only + accepts `exit` is in all `if` branches + accepts `return` is in `if` branch only + accepts `abort` is not in `elsif` branch + registers an offense for `throw` in all `if` branches with other expressions + accepts `return` is in all `if` branches + registers an offense for `abort` in all `if` branches + accepts `redo` is in `if`, and without `else` + registers an offense for `next` in all `if` and `elsif` branches + accepts code with conditional `exit` + registers an offense for `abort` in `begin` + accepts code with conditional `fail` + registers an offense for `exit!` in `begin` + registers an offense for `return` in all `case` branches + accepts `redo` is not in `elsif` branch + registers an offense for `exit!` in all `if` and `elsif` branches + accepts `retry` is in `case` branch without else + registers an offense for `fail` in all `if` branches + accepts `return` is in `else` branch only + accepts `fail` is in all `if` branches + registers an offense for `retry` in all `if` and `elsif` branches + accepts `redo` is in `else` branch only + accepts `redo` is in `case` branch without else + accepts `exit` is not in `elsif` branch + registers an offense for `fail` in all `case` branches + accepts `fail` is in `case` branch without else + registers an offense for `break` before other statements + registers an offense for `abort` in all `if` and `elsif` branches + accepts `exit` is in `if`, and without `else` + accepts `next` is in all `if` branches + registers an offense for `throw` before other statements + registers an offense for `exit` in `begin` + registers an offense for `break` in all `if` branches with other expressions + registers an offense for `exit` in all `if` and `elsif` branches + accepts code with conditional `exit!` + accepts code with conditional `break` + accepts `throw` is not in `elsif` branch + accepts `fail` as the final expression + accepts `next` is not in `elsif` branch + registers an offense for `exit` in all `case` branches + accepts `exit!` is in `else` branch only + accepts `exit!` is in `if`, and without `else` + registers an offense for `retry` in all `case` branches + accepts `raise` as the final expression + accepts `break` is in `case` branch without else + accepts `exit!` is in `case` branch without else + registers an offense for `exit!` before other statements + accepts `break` is in `if`, and without `else` + accepts `throw` is in `else` branch only + registers an offense for `exit!` in all `if` branches + registers an offense for `fail` in all `if` and `elsif` branches + accepts code with conditional `throw` + registers an offense for `fail` before other statements + registers an offense for `raise` in all `if` and `elsif` branches + accepts `throw` is in all `if` branches + registers an offense for `break` in all `if` branches + registers an offense for `next` in all `if` branches + accepts `return` is in `case` branch without else + registers an offense for `exit` in all `if` branches with other expressions + accepts `next` is in `case` branch without else + registers an offense for `redo` in all `if` and `elsif` branches + registers an offense for `redo` in all `if` branches + registers an offense for `return` in all `if` branches + registers an offense for `next` in all `case` branches + registers an offense for `redo` in all `case` branches + accepts `break` is in all `if` branches + accepts `next` is in `if`, and without `else` + accepts `break` is not in `elsif` branch + registers an offense for `next` before other statements + accepts `redo` is in all `if` branches + registers an offense for `retry` in `begin` + accepts `raise` is in `else` branch only + accepts `next` as the final expression + accepts `exit!` is not in `elsif` branch + registers an offense for `redo` in `begin` + accepts `throw` is in `if` branch only + accepts `exit!` is in all `if` branches + registers an offense for `retry` in all `if` branches + accepts `raise` is in `if`, and without `else` + accepts `raise` is not in `elsif` branch + accepts `retry` is in `if` branch only + accepts `next` is in `else` branch only + accepts `retry` as the final expression + registers an offense for `next` in all `if` branches with other expressions + registers an offense for `return` in all `if` and `elsif` branches + registers an offense for `fail` in all `if` branches with other expressions + registers an offense for `raise` in all `if` branches + accepts `retry` is not in `elsif` branch + accepts `throw` as the final expression + accepts code with conditional `raise` + accepts `break` as the final expression + registers an offense for `throw` in all `if` branches + registers an offense for `break` in all `case` branches + registers an offense for `throw` in `begin` + registers an offense for `exit!` in all `case` branches + registers an offense for `abort` in all `case` branches + accepts `raise` is in `if` branch only + registers an offense for `abort` before other statements + accepts `return` is not in `elsif` branch + accepts `abort` is in `if` branch only + registers an offense for `fail` in `begin` + accepts `abort` is in `if`, and without `else` + accepts code with conditional `return` + accepts `throw` is in `if`, and without `else` + registers an offense for `exit` before other statements + registers an offense for `retry` in all `if` branches with other expressions + accepts `return` as the final expression + accepts `raise` is in all `if` branches + registers an offense for `break` in `begin` + accepts code with conditional `redo` + accepts `exit` is in `case` branch without else + accepts `retry` is in `if`, and without `else` + accepts `throw` is in `case` branch without else + registers an offense for `redo` in all `if` branches with other expressions + accepts `exit` is in `if` branch only + accepts `break` is in `if` branch only + registers an offense for `raise` in `begin` + +RuboCop::Cop::Layout::SpaceInLambdaLiteral + when configured to enforce spaces + does not register an offense for multi-line lambdas + does not register an offense for no space between -> and { + registers an offense and corrects no space in both lambdas when nested + does not register an offense for a space between -> and ( + registers an offense and corrects no space between -> and ( + registers an offense and corrects no space in the inner nested lambda + registers an offense and corrects no space in the outer nested lambda + when configured to enforce no space + registers an offense and corrects a space between -> and ( + does not register an offense for multi-line lambdas + does not register an offense for a space between -> and { + does not register an offense for no space between -> and ( + registers an offense and corrects spaces between -> and ( + registers an offense and corrects a space in the inner nested lambda + registers an offense and corrects a space in the outer nested lambda + register offenses and correct spaces in both lambdas when nested + +RuboCop::Cop::Lint::UnexpectedBlockArity + registers multiple offenses + with a numblock + when given three parameters + does not register an offense + with no receiver + does not register an offense + when given one parameter + registers an offense + when given two parameters + does not register an offense + when given no parameters + registers an offense + when using enough parameters, but not all explicitly + does not register an offense + with a block + with optargs + with arity 2 + does not register an offense + with arity 1 + registers an offense + with no receiver + does not register an offense + when given a splat parameter + does not register an offense + when given two parameters + does not register an offense + when given one parameter + registers an offense + when destructuring + with arity 2 + does not register an offense + with arity 1 + registers an offense + when given three parameters + does not register an offense + with keyword args + registers an offense + with shadow args + registers an offense + with a keyword splat + registers an offense + when given no parameters + registers an offense + +RuboCop::Cop::Style::RedundantFetchBlock + with SafeForConstants: false + does not register an offense when using `#fetch` with constant in the block + with SafeForConstants: true + registers an offense and corrects when using `#fetch` with Integer in the block + registers an offense and corrects when using `#fetch` with Rational in the block + registers an offense and corrects when using `#fetch` with Complex in the block + registers an offense and corrects when using `#fetch` with Symbol in the block + does not register an offense when using `#fetch` with String in the block and strings are not frozen + does not register an offense when using `#fetch` with `Rails.cache` + does not register an offense when using `#fetch` with interpolated Symbol in the block + registers an offense and corrects when using `#fetch` with String in the block and strings are frozen + does not register an offense when using `#fetch` with argument fallback + registers an offense and corrects when using `#fetch` with Float in the block + registers an offense and corrects when using `#fetch` with empty block + registers an offense and corrects when using `#fetch` with constant in the block + does not register an offense when using `#fetch` with an argument in the block + +RuboCop::Cop::Style::RedundantStringEscape + does not register an offense for a __dir__ literal + does not register an offense for a regexp literal + does not register an offense for a x-str literal + does not register an offense for a __FILE__ literal + with a %(...) literal + behaves like a literal with interpolation + does not register an offense for multiple unicode escapes + does not register an offense for an escaped cvar interpolation + registers an offense and corrects an escaped # before interpolation + does not register an offense for a @-escaped cvar interpolation + does not register an offense for an escaped delimiter + does not register an offense for a technically-unnecessary escape + does not register an offense for control characters + does not register an offense for an escaped delimiter before interpolation + does not register an offense for an escaped gvar interpolation + does not register an offense for an escaped newline + does not register an offense for a unicode escape + registers an offense and corrects an escaped # at end-of-string + does not register an offense for a bracket-escaped interpolation + does not register an offense for an escaped # followed { + does not register an offense without escapes + does not register an offense for an escaped backslash + does not register an offense for a hex escape + does not register a bracket-escaped lvar interpolation + does not register an offense for a $-escaped gvar interpolation + does not register an offense for a @-escaped ivar interpolation + registers an offense and corrects an escaped double quote + does not register an offense for an escaped interpolation + does not register an offense for a newline + does not register an offense for an octal escape + registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation + does not register an offense for a meta character + registers an offense and corrects an escaped # without following { + registers an offense and corrects a escaped nested delimiter in a double quoted string + does not register an offense for an ascii DEL + does not register an offense for an escaped ivar interpolation + does not register an offense for meta control characters + registers an offense and corrects an escaped single quote + with an interpolation-enabled HEREDOC + does not register an offense for a heredoc interpolating a string with an allowed escape + does not register an offense for a nested heredoc without interpolation + registers an offense and corrects an escaped # without following { + does not register an offense for a @-escaped ivar interpolation + does not register an offense for control characters + does not register an offense for a $-escaped gvar interpolation + does not register an offense for an octal escape + registers an offense and corrects an escaped # before interpolation + does not register an offense for a newline + does not register a bracket-escaped lvar interpolation + does not register an offense for a bracket-escaped interpolation + does not register an offense for a hex escape + does not register an offense for a @-escaped cvar interpolation + does not register an offense for a technically-unnecessary escape + does not register an offense for an escaped # followed { + does not register an offense for an escaped gvar interpolation + does not register an offense for meta control characters + does not register an offense for an escaped ivar interpolation + registers an offense and corrects an escaped single quote + does not register an offense for an escaped interpolation + does not register an offense for a meta character + does not register an offense for an escaped newline + registers an offense and corrects an escaped # at end-of-string + does not register an offense for an ascii DEL + does not register an offense for multiple unicode escapes + does not register an offense for an escaped cvar interpolation + does not register an offense without escapes + does not register an offense for an escaped backslash + does not register an offense for a unicode escape + with a %w(...) literal + does not register an offense for escaped spaces + behaves like a literal without interpolation + does not register an offense with escaped single quote + does not register an offense for a bracket-escaped interpolation + does not register an offense for a meta character + does not register an offense for a technically-unnecessary escape + does not register an offense for an escaped newline + does not register an offense for an escaped # with following { + does not register an offense for an escaped cvar interpolation + does not register an offense for an escaped gvar interpolation + does not register an offense for an escaped interpolation + does not register an offense for a @-escaped cvar interpolation + does not register a bracket-escaped lvar interpolation + does not register an offense for an escaped # followed { + does not register an offense for multiple unicode escapes + does not register an offense for a $-escaped gvar interpolation + does not register an offense for an escaped backslash + does not register an offense for a unicode escape + does not register an offense for a newline + does not register an offense without escapes + does not register an offense for a hex escape + does not register an offense for meta control characters + does not register an offense for an octal escape + does not register an offense for an escaped delimiter before interpolation + does not register an offense with escaped double quote + does not register an offense for an escaped ivar interpolation + does not register an offense for an allowed escape inside multi-line literal + does not register an offense with escaped # at end-of-string + does not register an offense for an ascii DEL + does not register an offense with escaped # without following { + does not register an offense for an escaped delimiter + does not register an offense for control characters + does not register an offense for a @-escaped ivar interpolation + with a %W(...) literal + does not register an offense for escaped spaces + behaves like a literal with interpolation + does not register an offense for a meta character + does not register an offense for control characters + registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation + does not register an offense for a @-escaped cvar interpolation + does not register an offense for an ascii DEL + registers an offense and corrects an escaped single quote + does not register an offense for an escaped delimiter + does not register an offense for a $-escaped gvar interpolation + does not register an offense for a technically-unnecessary escape + does not register an offense for a hex escape + registers an offense and corrects an escaped double quote + does not register an offense for an escaped backslash + does not register an offense without escapes + registers an offense and corrects an escaped # without following { + does not register an offense for a newline + does not register an offense for an escaped delimiter before interpolation + registers an offense and corrects an escaped # before interpolation + does not register an offense for multiple unicode escapes + does not register a bracket-escaped lvar interpolation + does not register an offense for an octal escape + does not register an offense for meta control characters + does not register an offense for an escaped cvar interpolation + does not register an offense for an escaped ivar interpolation + does not register an offense for an escaped gvar interpolation + registers an offense and corrects a escaped nested delimiter in a double quoted string + does not register an offense for a unicode escape + does not register an offense for an escaped newline + does not register an offense for an escaped # followed { + registers an offense and corrects an escaped # at end-of-string + does not register an offense for a bracket-escaped interpolation + does not register an offense for a @-escaped ivar interpolation + does not register an offense for an escaped interpolation + with an interpolation-disabled HEREDOC + behaves like a literal without interpolation + does not register an offense with escaped double quote + does not register an offense without escapes + does not register an offense for a unicode escape + does not register an offense for multiple unicode escapes + does not register an offense for an escaped # followed { + does not register an offense for an escaped # with following { + does not register an offense for an escaped backslash + does not register an offense for a $-escaped gvar interpolation + does not register an offense for an escaped ivar interpolation + does not register an offense for a bracket-escaped interpolation + does not register an offense for an octal escape + does not register an offense for a @-escaped cvar interpolation + does not register an offense for a newline + does not register an offense for meta control characters + does not register a bracket-escaped lvar interpolation + does not register an offense for a meta character + does not register an offense for an ascii DEL + does not register an offense for a technically-unnecessary escape + does not register an offense for control characters + does not register an offense with escaped # at end-of-string + does not register an offense for a hex escape + does not register an offense for an escaped newline + does not register an offense for a @-escaped ivar interpolation + does not register an offense for an escaped interpolation + does not register an offense for an allowed escape inside multi-line literal + does not register an offense for an escaped cvar interpolation + does not register an offense with escaped single quote + does not register an offense with escaped # without following { + does not register an offense for an escaped gvar interpolation + with a %Q(...) literal + behaves like a literal with interpolation + registers an offense and corrects an escaped # at end-of-string + does not register an offense for a $-escaped gvar interpolation + does not register an offense for multiple unicode escapes + registers an offense and corrects an escaped single quote + does not register an offense for a meta character + registers an offense and corrects an escaped double quote + does not register an offense for an octal escape + does not register an offense for an escaped delimiter + registers an offense and corrects an escaped # before interpolation + does not register an offense for an escaped backslash + does not register an offense for an escaped newline + does not register an offense for a unicode escape + does not register an offense for meta control characters + does not register an offense for an escaped gvar interpolation + does not register an offense for a newline + registers an offense and corrects a escaped nested delimiter in a double quoted string + does not register an offense for an escaped delimiter before interpolation + does not register an offense for an escaped cvar interpolation + registers an offense and corrects an escaped # without following { + does not register an offense for a @-escaped cvar interpolation + does not register an offense for a hex escape + does not register an offense for an escaped # followed { + registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation + does not register an offense for an escaped ivar interpolation + does not register an offense for an escaped interpolation + does not register an offense for a bracket-escaped interpolation + does not register an offense for a @-escaped ivar interpolation + does not register an offense without escapes + does not register an offense for an ascii DEL + does not register an offense for a technically-unnecessary escape + does not register an offense for control characters + does not register a bracket-escaped lvar interpolation + with a %Q!...! literal + behaves like a literal with interpolation + does not register an offense for a bracket-escaped interpolation + does not register an offense for an ascii DEL + does not register an offense for an escaped backslash + registers an offense and corrects an escaped # before interpolation + does not register an offense for meta control characters + registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation + does not register an offense for multiple unicode escapes + does not register an offense for a meta character + does not register an offense for a unicode escape + does not register an offense for an escaped # followed { + registers an offense and corrects an escaped # at end-of-string + registers an offense and corrects an escaped single quote + does not register an offense for a hex escape + does not register an offense for an escaped newline + does not register an offense without escapes + does not register an offense for an octal escape + does not register an offense for an escaped interpolation + does not register an offense for an escaped cvar interpolation + registers an offense and corrects a escaped nested delimiter in a double quoted string + does not register an offense for an escaped delimiter + does not register a bracket-escaped lvar interpolation + does not register an offense for an escaped ivar interpolation + does not register an offense for an escaped gvar interpolation + does not register an offense for a @-escaped ivar interpolation + registers an offense and corrects an escaped # without following { + does not register an offense for a $-escaped gvar interpolation + does not register an offense for an escaped delimiter before interpolation + does not register an offense for control characters + registers an offense and corrects an escaped double quote + does not register an offense for a technically-unnecessary escape + does not register an offense for a newline + does not register an offense for a @-escaped cvar interpolation + with a %q(...) literal + behaves like a literal without interpolation + does not register an offense for an escaped # with following { + does not register an offense for an escaped gvar interpolation + does not register an offense for an escaped ivar interpolation + does not register an offense for an escaped delimiter before interpolation + does not register an offense for an escaped # followed { + does not register an offense with escaped # without following { + does not register an offense for an escaped interpolation + does not register an offense for meta control characters + does not register an offense with escaped # at end-of-string + does not register an offense for an escaped backslash + does not register an offense for control characters + does not register an offense for a hex escape + does not register a bracket-escaped lvar interpolation + does not register an offense for an escaped delimiter + does not register an offense for an octal escape + does not register an offense for a meta character + does not register an offense for a newline + does not register an offense for a @-escaped cvar interpolation + does not register an offense for a unicode escape + does not register an offense with escaped double quote + does not register an offense for an escaped newline + does not register an offense for an escaped cvar interpolation + does not register an offense with escaped single quote + does not register an offense for an ascii DEL + does not register an offense for multiple unicode escapes + does not register an offense for a $-escaped gvar interpolation + does not register an offense without escapes + does not register an offense for a bracket-escaped interpolation + does not register an offense for a @-escaped ivar interpolation + does not register an offense for an allowed escape inside multi-line literal + does not register an offense for a technically-unnecessary escape + when using character literals + does not register an offense for `?a` + does not register an offense for `?\n` + with a single quoted string + behaves like a literal without interpolation + does not register an offense for an escaped cvar interpolation + does not register an offense without escapes + does not register an offense for control characters + does not register an offense for meta control characters + does not register an offense for an escaped newline + does not register an offense for an allowed escape inside multi-line literal + does not register an offense with escaped # without following { + does not register an offense for an ascii DEL + does not register an offense for a newline + does not register an offense for a meta character + does not register an offense for an escaped ivar interpolation + does not register an offense with escaped double quote + does not register an offense for a unicode escape + does not register an offense for an escaped # with following { + does not register an offense for an octal escape + does not register an offense for an escaped delimiter + does not register an offense for an escaped # followed { + does not register an offense for a @-escaped cvar interpolation + does not register a bracket-escaped lvar interpolation + does not register an offense for a @-escaped ivar interpolation + does not register an offense for a technically-unnecessary escape + does not register an offense for an escaped delimiter before interpolation + does not register an offense for an escaped gvar interpolation + does not register an offense with escaped single quote + does not register an offense for a bracket-escaped interpolation + does not register an offense with escaped # at end-of-string + does not register an offense for an escaped interpolation + does not register an offense for multiple unicode escapes + does not register an offense for a $-escaped gvar interpolation + does not register an offense for a hex escape + does not register an offense for an escaped backslash + with a double quoted string + does not register an offense with multiple escaped backslashes + registers an offense and corrects an unnecessary escape in multi-line broken string + does not register an offense with escaped double quote + does not register an offense when escaping a quote in multi-line broken string + behaves like a literal with interpolation + does not register an offense for an escaped delimiter before interpolation + registers an offense and corrects an escaped # without following { + does not register an offense for an escaped # followed { + does not register an offense for a @-escaped cvar interpolation + does not register an offense for a @-escaped ivar interpolation + does not register an offense for a technically-unnecessary escape + does not register an offense for a bracket-escaped interpolation + does not register an offense for meta control characters + does not register an offense for an ascii DEL + does not register an offense for an escaped newline + does not register an offense for an escaped ivar interpolation + does not register an offense for an escaped cvar interpolation + registers an offense and corrects an escaped single quote + does not register an offense for a hex escape + registers an offense and corrects an escaped } when escaping both brackets to avoid interpolation + does not register an offense for an escaped interpolation + does not register an offense without escapes + does not register a bracket-escaped lvar interpolation + does not register an offense for control characters + registers an offense and corrects an escaped # at end-of-string + does not register an offense for an escaped gvar interpolation + does not register an offense for multiple unicode escapes + does not register an offense for a $-escaped gvar interpolation + does not register an offense for an escaped delimiter + does not register an offense for an octal escape + does not register an offense for a unicode escape + does not register an offense for a meta character + does not register an offense for a newline + registers an offense and corrects an escaped # before interpolation + does not register an offense for an escaped backslash + +RuboCop::Cop::Layout::EmptyLinesAroundClassBody + when EnforcedStyle is empty_lines + accepts singleton classes with an empty body + accepts classes with an empty body + registers an offense for class body not starting or ending with a blank + registers an offense for singleton class body not starting or ending with a blank + does not register offenses when specifying a superclass that breaks the line + does not register offenses + when EnforcedStyle is beginning_only + ignores empty lines at the beginning of a class + registers an offense for an empty line at the end of a class + when EnforcedStyle is ending_only + registers an offense for an empty line at the end of a class + ignores empty lines at the beginning of a class + when EnforcedStyle is no_empty_lines + registers an offense for class body ending with a blank + autocorrects singleton class body containing only a blank + registers an offense for singleton class body ending with a blank + registers an offense for class body starting with a blank + when EnforcedStyle is empty_lines_except_namespace + when only child is class + registers offenses for namespaced class body not ending with a blank + requires no empty lines for namespace + registers offenses for namespaced class body not starting with a blank + registers offense for namespace body ending with a blank + registers offense for namespace body starting with a blank + autocorrects beginning and end + when only child is module + requires no empty lines for namespace + registers offense for namespace body starting with a blank + registers offense for namespace body ending with a blank + when has multiple child classes + requires empty lines for namespace + registers offenses for namespace body starting and ending without a blank + when EnforcedStyle is empty_lines_special + when namespace has multiple children + requires empty lines for namespace + when first child is an access modifier + with no blank lines at the beginning and ending of class body + registers and corrects an offense + with blank lines at the beginning and ending of class body + registers no offense + when first child is NOT a method + does not require blank line at the beginning of class body but requires blank line before first def definition and requires blank line at the end of class body + source without blank lines + registers an offense for class not ending with a blank line + source with blank lines + registers an offense for class beginning with a blank line + source with comment before method definition + registers an offense for class beginning with a blank line + when class has a namespace + requires no empty lines for namespace and does not require blank line at the beginning of class body but requires blank line at the end of class body + source with blank lines + registers and autocorrects the offenses + source without blank lines + registers and autocorrects the offenses + source with constants + registers and autocorrects the offenses + when first child is a method + requires blank line at the beginning and ending of class body + source without blank lines + registers an offense for class not beginning and ending with a blank line + when class has a namespace + requires no empty lines for namespace but requires blank line at the beginning and ending of class body + source with blank lines + autocorrects the offenses + source without blank lines + registers and autocorrects the offenses + class with only constants + registers and autocorrects the offenses + class with constant and child class + registers and autocorrects the offenses + class with empty body + without empty line + does NOT register offenses + with empty line + does NOT register offenses + +RuboCop::Cop::Lint::ScriptPermission + with stdin + skips investigation + with file permission 0644 + registers an offense for script permission + if autocorrection is off + leaves the file intact + with file permission 0755 + accepts with shebang line + accepts with blank + accepts without shebang line + +RuboCop::Cop::Lint::UselessElseWithoutRescue + with `else` with `rescue` + accepts + with `else` without `rescue` + registers an offense + +RuboCop::Cop::Lint::BooleanSymbol + does not register an offense when used inside percent-literal symbol array + does not register an offense when using `true` + registers an offense when using `:false` + does not register an offense when using regular symbol + does not register an offense when using `false` + registers an offense when using `:true` + when using the new hash syntax + registers an offense when using `false:` + registers an offense when using `true:` + registers an offense when using `key: :false` + +RuboCop::Cop::Style::FormatStringToken + ignores placeholder arguments + ignores time format when it is stored in a variable + ignores time format (when used as argument to strptime) + supports flags and modifiers + ignores percent escapes + works inside hashes + ignores `%r` regexp + handles dstrs + ignores time format and unrelated `format` method using + ignores xstr + ignores regexp + ignores http links + ignores __FILE__ + ignores time format (when used as argument to strftime) + behaves like enforced styles for format string tokens + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + registers offenses for template style + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + detects when the cop must be disabled to avoid offenses + does not register offenses for annotated style + supports dynamic string with interpolation + #correctable_sequence? + configures the enforced style to template after inspecting "%{a}" + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is unannotated + gives a helpful error message + behaves like enforced styles for format string tokens + when enforced style is template + detects when the cop must be disabled to avoid offenses + configures the enforced style to template after inspecting "%{a}" + supports dynamic string with interpolation + #correctable_sequence? + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + sets the enforced style to annotated after inspecting "%s" + #correctable_sequence? + registers offenses for template style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is annotated + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + registers offenses for template style + sets the enforced style to annotated after inspecting "%s" + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when enforced style is template + does not register offenses for annotated style + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + configures the enforced style to template after inspecting "%{a}" + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is unannotated + #correctable_sequence? + behaves like enforced styles for format string tokens + when enforced style is template + #correctable_sequence? + configures the enforced style to template after inspecting "%{a}" + does not register offenses for annotated style + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + #correctable_sequence? + registers offenses for template style + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + gives a helpful error message + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + configures the enforced style to template after inspecting "%{a}" + does not register offenses for annotated style + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is annotated + #correctable_sequence? + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + registers offenses for template style + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + behaves like enforced styles for format string tokens + when enforced style is annotated + #correctable_sequence? + supports dynamic string with interpolation + sets the enforced style to annotated after inspecting "%s" + registers offenses for template style + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is template + does not register offenses for annotated style + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + configures the enforced style to template after inspecting "%{a}" + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? + behaves like enforced styles for format string tokens + when enforced style is annotated + registers offenses for template style + supports dynamic string with interpolation + #correctable_sequence? + sets the enforced style to annotated after inspecting "%s" + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + supports dynamic string with interpolation + #correctable_sequence? + configures the enforced style to template after inspecting "%{a}" + detects when the cop must be disabled to avoid offenses + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + #correctable_sequence? + does not register offenses for annotated style + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + configures the enforced style to template after inspecting "%{a}" + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + registers offenses for template style + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + behaves like enforced styles for format string tokens + when enforced style is template + #correctable_sequence? + configures the enforced style to template after inspecting "%{a}" + supports dynamic string with interpolation + does not register offenses for annotated style + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + detects when the cop must be disabled to avoid offenses + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + registers offenses for template style + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + #correctable_sequence? + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + registers offenses for template style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is template + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + #correctable_sequence? + configures the enforced style to template after inspecting "%{a}" + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is annotated + registers offenses for template style + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + sets the enforced style to annotated after inspecting "%s" + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when enforced style is template + configures the enforced style to template after inspecting "%{a}" + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is unannotated + #correctable_sequence? + behaves like enforced styles for format string tokens + when enforced style is template + supports dynamic string with interpolation + configures the enforced style to template after inspecting "%{a}" + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when enforced style is annotated + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + registers offenses for template style + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + #correctable_sequence? + sets the enforced style to annotated after inspecting "%s" + registers offenses for template style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is template + registers offenses for annotated style + configures the enforced style to template after inspecting "%{a}" + supports dynamic string with interpolation + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when enforced style is annotated + gives a helpful error message + when AllowedMethods is disabled + registers an offense + when AllowedMethods is enabled + registers an offense for different method call within ignored method + does not register an offense for value in nested structure + does not register an offense + when AllowedPatterns is disabled + registers an offense + when AllowedPatterns is enabled + does not register an offense + registers an offense for different method call within ignored method + does not register an offense for value in nested structure + behaves like enforced styles for format string tokens + when enforced style is annotated + detects when the cop must be disabled to avoid offenses + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + #correctable_sequence? + registers offenses for template style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + #correctable_sequence? + does not register offenses for annotated style + supports dynamic string with interpolation + configures the enforced style to template after inspecting "%{a}" + detects when the cop must be disabled to avoid offenses + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is template + does not register offenses for annotated style + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + configures the enforced style to template after inspecting "%{a}" + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + #correctable_sequence? + sets the enforced style to annotated after inspecting "%s" + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + registers offenses for template style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + registers offenses for template style + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when enforced style is template + does not register offenses for annotated style + configures the enforced style to template after inspecting "%{a}" + #correctable_sequence? + detects when the cop must be disabled to avoid offenses + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + does not register offenses for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is unannotated + #correctable_sequence? + when enforced style is template + configures the enforced style to template after inspecting "%{a}" + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + does not register offenses for annotated style + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is annotated + detects when the cop must be disabled to avoid offenses + sets the enforced style to annotated after inspecting "%s" + supports dynamic string with interpolation + registers offenses for template style + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for single unannotated + registers offense for dual unannotated + behaves like enforced styles for format string tokens + when enforced style is template + supports dynamic string with interpolation + detects when the cop must be disabled to avoid offenses + does not register offenses for annotated style + configures the enforced style to template after inspecting "%{a}" + #correctable_sequence? + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for single unannotated + does not register offenses for dual unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when enforced style is annotated + sets the enforced style to annotated after inspecting "%s" + registers offenses for template style + detects when the cop must be disabled to avoid offenses + #correctable_sequence? + supports dynamic string with interpolation + behaves like maximum allowed unannotated + when MaxUnannotatedPlaceholdersAllowed is 2 + does not register offenses for dual unannotated + does not register offenses for single unannotated + when MaxUnannotatedPlaceholdersAllowed is 1 + registers offense for dual unannotated + does not register offenses for single unannotated + when enforced style is unannotated + #correctable_sequence? -RuboCop::Cop::Lint::UnifiedInteger - target ruby version < 2.4 - when Fixnum - without any decorations - registers an offense and autocorrects - when explicitly specified as toplevel constant - registers an offense - with MyNamespace - does not register an offense - target ruby version < 2.4 - when Bignum - when explicitly specified as toplevel constant - registers an offense - without any decorations - registers an offense and autocorrects - with MyNamespace - does not register an offense - target ruby version >= 2.4 - when Bignum - when explicitly specified as toplevel constant - registers an offense - with MyNamespace - does not register an offense - without any decorations - registers an offense - target ruby version >= 2.4 - when Fixnum - with MyNamespace - does not register an offense - when explicitly specified as toplevel constant - registers an offense - without any decorations +RuboCop::Cop::Style::NestedParenthesizedCalls + on a call with no arguments, nested in a parenthesized one + doesn't register an offense + on a method call with no arguments + doesn't register an offense + on a non-parenthesized call nested in a parenthesized one + with a single argument to the nested call + registers an offense + when using safe navigation operator registers an offense - when Integer - with MyNamespace - does not register an offense - when explicitly specified as toplevel constant - does not register an offense - without any decorations - does not register an offense + with multiple arguments to the nested call + registers an offense + on a non-parenthesized method call + doesn't register an offense + on a nested, parenthesized method call + doesn't register an offense + on a permitted method + doesn't register an offense + on an aref, nested in a parenthesized method call + doesn't register an offense + on a call to a setter method + doesn't register an offense + on a deeply nested argument + doesn't register an offense + backslash newline in method call + registers an offense -RuboCop::Options - option - --auto-gen-only-exclude - fails if given without --auto-gen-config - --require - requires the passed path - --no-parallel - disables parallel from file - --exclude-limit - fails if given without --auto-gen-config - fails if given first without argument - fails if given last without argument - fails if given alone without argument - --display-only-correctable - fails if given with --display-only-failed - fails if given with an autocorrect argument - --display-only-failed - fails if given without --format junit - works if given with --format junit - --fix-layout - sets some autocorrect options - deprecated options - --auto-correct-all - emits a warning and sets the correct options instead - --safe-auto-correct - emits a warning and sets the correct options instead - --auto-correct - emits a warning and sets the correct options instead - --disable-uncorrectable - accepts together with a safe autocorrect argument - fails if given without an autocorrect argument - accepts together with an unsafe autocorrect argument - --autocorrect-all - sets some autocorrect options - --regenerate-todo - when todo options are overridden after --regenerate-todo - is expected to eq {:auto_gen_config=>true, :exclude_limit=>"50", :offense_counts=>false, :regenerate_todo=>true} - when todo options are overridden before --regenerate-todo - is expected to eq {:auto_gen_config=>true, :exclude_limit=>"50", :offense_counts=>false, :regenerate_todo=>true} - when disabled options are overridden to be enabled - is expected to eq {:auto_gen_config=>true, :exclude_limit=>"100", :offense_counts=>true, :regenerate_todo=>true} - when no other options are given - is expected to eq {:auto_gen_config=>true, :exclude_limit=>"100", :offense_counts=>false, :regenerate_todo=>true} - --raise-cop-error - raises cop errors - --display-only-fail-level-offenses - fails if given with an autocorrect argument - -h/--help - shows help text - exits cleanly - lists all builtin formatters - --cache-root - fails if no argument is given - fails if also `--cache false` is given - accepts a path as argument - --autocorrect - Specify --autocorrect and --autocorrect-all - emits a warning and sets some autocorrect options - Specify only --autocorrect - sets some autocorrect options - --cache - accepts false as argument - fails if no argument is given - fails if unrecognized argument is given - accepts true as argument - -s/--stdin - succeeds with exactly one path - fails if more than one path is given - fails if no paths are given - incompatible cli options - rejects using -V with --show-cops - rejects using -v with -V - rejects using -v with --show-cops - mentions all incompatible options when more than two are used - --fail-level - accepts full severity names - accepts severity initial letters - accepts the "fake" severities A/autocorrect - --parallel - combined with --cache false - ignores --parallel - combined with an autocorrect argument - combined with --autocorrect - allows --parallel - combined with --fix-layout - allows --parallel - combined with --autocorrect-all - allows --parallel - combined with --fail-fast - ignores --parallel - combined with two incompatible arguments - ignores --parallel and lists both incompatible arguments - combined with --auto-gen-config - ignores --parallel - --auto-gen-config - accepts other options - options precedence - .rubocop file - has lower precedence then options from RUBOCOP_OPTS env variable - has lower precedence then command line options - .rubocop directory - is ignored and command line options are used - RUBOCOP_OPTS environment variable - has higher precedence then options from .rubocop file - has lower precedence then command line options +RuboCop::Cop::Metrics::CyclomaticComplexity + when AllowedPatterns is enabled + does not register an offense when using `define_method` + does not register an offense when defining an instance method + does not register an offense when defining a class method + when Max is 1 + deals with nested if blocks containing && and || + registers an offense for a case/when block + registers an offense for a while block + registers an offense for a ternary operator + does not count blocks in general + registers an offense for or + counts enumerating methods with block-pass as +1 + registers an offense for an elsif block + registers an offense for a rescue block + registers an offense for &. + registers an offense for a for block + registers an offense for && + accepts a method with no decision points + registers an offense for an unless modifier + registers an offense for an if modifier + registers an offense for and + registers an offense for &&= + accepts complex code outside of methods + accepts an empty `define_method` + counts repeated &. on same untouched local variable as 1 + registers an offense for an until block + accepts an empty method + registers an offense for || + registers an offense for a `define_method` + registers an offense for ||= + counts only a single method + counts enumerating methods with blocks as +1 + Ruby 2.7 + counts enumerating methods with numblocks as +1 + when AllowedMethods is enabled + does not register an offense when using `define_method` + does not register an offense when defining an instance method + does not register an offense when defining a class method + when Max is 2 + counts stupid nested if and else blocks -RuboCop::Cop::Layout::InitialIndentation - registers an offense and corrects indented assignment disregarding comment - accepts unindented comment + assignment - accepts empty file - accepts unindented method definition - registers an offense for indented method definition - for a file with byte order mark - accepts unindented method call - registers an offense and corrects indented method call after comment - registers an offense and corrects indented method call +RuboCop::Cop::Style::BlockDelimiters + EnforcedStyle: line_count_based + does not autocorrect {} if do-end would change the meaning + accepts a multi-line block with do-end + registers an offense for a single line block with do-end + accepts a single line block with braces + autocorrects do-end for single line blocks to { and } + accepts a multi-line block that needs braces to be valid ruby + does not autocorrect do-end if {} would change the meaning + Ruby >= 2.7 + accepts a multi-line numblock with do-end + registers an offense for a single line numblock with do-end + accepts a multi-line numblock that needs braces to be valid ruby + accepts a single line numblock with braces + with a single line do-end block with an inline `rescue` + autocorrects properly + when there are braces around a multi-line block + autocorrects { and } to do and end + accepts braces if do-end would change the meaning + registers an offense for braces if do-end would not change the meaning + does not autocorrect {} if do-end would introduce a syntax error + can handle special method names such as []= and done? + registers an offense in the simple case + registers an offense and keep chained block when there is a comment after the closing brace and block body is not empty + autocorrects adjacent curly braces correctly + registers an offense when there is a comment after the closing brace and block body is not empty + registers an offense when combined with attribute assignment + accepts a multi-line functional block with {} if it is an ignored method by regex + registers an offense when there is a comment after the closing brace and using method chain + accepts a multi-line functional block with {} if it is an ignored method + registers an offense when there is a comment after the closing brace and block body is empty + EnforcedStyle: semantic + registers an offense for a multi-line block with do-end if the return value is passed to a method + registers an offense for a multi-line block with do-end if the return value is attribute-assigned + accepts a single line block with {} followed by a safe navigation method call + accepts a single line block with {} if used in an erange + autocorrects do-end to {} with appropriate spacing + accepts a single line block with {} if used in a logical or + accepts a multi-line block with braces if the return value is assigned + accepts a multi-line functional block with do-end if it is a known procedural method + allows {} if it is a known functional method + allows {} if it is a known procedural method + accepts a multi-line functional block with do-end if it is an ignored method by regex + accepts a multi-line block with braces if it is the return value of its scope + accepts a multi-line block with braces when passed to a method + accepts a multi-line block with braces when passed to a known functional method + accepts a single line block with {} if used in a logical and + autocorrects do-end with `rescue` to {} if it is a functional block + registers an offense for a multi-line block with do-end if the return value is assigned + accepts a multi-line block with do-end if it is the return value of its scope + accepts a multi-line block with braces when chained + accepts a multi-line functional block with do-end if it is an ignored method + registers an offense for a multi-line block with braces if the return value is not used + accepts a single line block with {} if used in an array + accepts a single line block with {} if used in an if statement + accepts a single line block with {} if used in an irange + autocorrects do-end to {} if it is a functional block and does not change the meaning + autocorrects do-end to {} if it is a functional block + autocorrects do-end with `ensure` to {} if it is a functional block + with a procedural one-line block + with AllowBracesOnProceduralOneLiners false or unset + accepts a single line block with do-end if it is procedural + registers an offense for a single line procedural block + with AllowBracesOnProceduralOneLiners true + accepts a single line procedural block with braces + accepts a single line procedural do-end block + with a procedural multi-line block + autocorrects { and } to do and end with appropriate spacing + autocorrects { and } to do and end + EnforcedStyle: always_braces + registers an offense for a single line block with do-end + registers an offense for multi-line chained do-end blocks + autocorrects do-end with `ensure` to {} if it is a functional block + accepts a multi-line functional block with do-end if it is an ignored method by regex + does not autocorrect do-end if {} would change the meaning + registers an offense for a multi-line block with do-end + registers an offense for multi-lined do-end blocks when combined with attribute assignment + autocorrects do-end with `rescue` to {} if it is a functional block + accepts a single line block with braces + accepts a multi-line block that needs braces to be valid ruby + accepts a multi-line functional block with do-end if it is an ignored method + when there are braces around a multi-line block + allows in the simple case + allows when combined with attribute assignment + allows when the block is being chained + BracesRequiredMethods + BracesRequiredMethods methods + registers an offense with do + allows braces + other methods + autocorrects { and } to do and end + allows braces + EnforcedStyle: braces_for_chaining + allows do/end inside Hash[] + registers an offense for a single line block with do-end + registers an offense for multi-line chained do-end blocks + allows when :[] is chained + accepts a multi-line block that needs braces to be valid ruby + accepts a multi-line functional block with {} if it is an ignored method by regex + allows chaining to } inside of Hash[] + accepts a multi-line block with do-end + disallows {} with no chain inside of Hash[] + autocorrects do-end with `rescue` to {} if it is a functional block + accepts a single line block with braces + accepts a multi-line functional block with {} if it is an ignored method + autocorrects do-end with `ensure` to {} if it is a functional block + Ruby >= 2.7 + accepts a multi-line numblock with do-end + accepts a multi-line numblock that needs braces to be valid ruby + registers an offense for a single line numblock with do-end + accepts a single line numblock with braces + when there are braces around a multi-line block + allows when the block is being chained with attribute assignment + registers an offense in the simple case + allows when the block is being chained + registers an offense when combined with attribute assignment + with safe navigation + registers an offense for multi-line chained do-end blocks -RuboCop::ConfigObsoletion::RenamedCop - #message - when the cop has changed names but in the same department - is expected to start with "The `Style/MyCop` cop has been renamed to `Style/NewCop`" - when the cop has been moved to a new department - is expected to start with "The `Style/MyCop` cop has been moved to `Layout/MyCop`" - when the cop has changed names but in a new department - is expected to start with "The `Style/MyCop` cop has been renamed to `Layout/NewCop`" +RuboCop::Cop::Lint::NoReturnInBeginEndBlocks + rejects a return statement inside a block when using += + accepts a block with no return when using -= + rejects a return statement inside a block when using **= + rejects a return statement inside a block when using /= + rejects a return statement inside a block when using -= + accepts a block with no return when using *= + rejects a return statement inside a block when using *= + rejects a return statement inside a block when using = + accepts a block with no return when using /= + accepts a block with no return when using += + accepts a block with no return when using **= + accepts a block with no return when using ||= + accepts a block with no return when using = + rejects a return statement inside a block when using ||= -RuboCop::Cop::Style::RedundantFreeze - allows .freeze on method call - behaves like immutable objects - registers an offense for frozen (a > b) - behaves like mutable objects - allows ('a' + 'b') with freeze - behaves like mutable objects - allows 'str' with freeze - behaves like mutable objects - allows { a: 1, b: 2 } with freeze - behaves like mutable objects - allows ([42] * 42) with freeze - behaves like immutable objects - registers an offense for frozen (2 > 1) - behaves like immutable objects - registers an offense for frozen 1.5 - behaves like immutable objects - registers an offense for frozen :sym - behaves like mutable objects - allows ENV['foo'] with freeze - behaves like mutable objects - allows ::ENV['foo'] with freeze - behaves like mutable objects - allows "top#{1 + 2}" with freeze - behaves like mutable objects - allows (a + b) with freeze - behaves like mutable objects - allows ('a' * 20) with freeze - behaves like immutable objects - registers an offense for frozen [1, 2, 3].size - behaves like immutable objects - registers an offense for frozen 'foo'.count - behaves like immutable objects - registers an offense for frozen 1 - when the receiver is a string literal - Regexp and Range literals - Ruby 3.0 or higher - behaves like immutable objects - registers an offense for frozen /./ - behaves like immutable objects - registers an offense for frozen (1...5) - behaves like immutable objects - registers an offense for frozen (1..5) - Ruby 2.7 or lower - behaves like mutable objects - allows (1..5) with freeze - behaves like mutable objects - allows (1...5) with freeze - behaves like mutable objects - allows /./ with freeze - Ruby 3.0 or higher - when the frozen string literal comment is false - behaves like mutable objects - allows "#{a}" with freeze - when the frozen string literal comment is true - behaves like mutable objects - allows "#{a}" with freeze - when the frozen string literal comment is missing - behaves like mutable objects - allows "#{a}" with freeze - Ruby 2.7 or lower - when the frozen string literal comment is true - behaves like immutable objects - registers an offense for frozen "#{a}" - when the frozen string literal comment is missing - behaves like mutable objects - allows "#{a}" with freeze - when the frozen string literal comment is false - behaves like mutable objects - allows "#{a}" with freeze - behaves like mutable objects - allows [1, 2, 3] with freeze - behaves like immutable objects - registers an offense for frozen ('a' > 'b') - behaves like immutable objects - registers an offense for frozen (1 + 2) - behaves like immutable objects - registers an offense for frozen :"" +RuboCop::Cop::Lint::DuplicateRequire + registers and corrects an offense when duplicate `require` is detected + registers and corrects an offense for duplicate non top-level requires + registers and corrects an offense when duplicate `require_relative` is detected + does not register an offense when using single `require` + does not register an offense when there are no duplicate `require`s + registers and corrects an offense for multiple duplicate requires + does not register an offense when same feature argument but different require method + registers and corrects an offense when duplicate `require` through `Kernel` is detected + does not register an offense when calling user-defined `require` method + registers and corrects an offense when duplicate requires are interleaved with some other code -RuboCop::Cop::Lint::ToEnumArguments - does not register an offense when not inside method definition - does not register an offense when enumerator is created with `:m` and the correct arguments - registers an offense when required keyword arg is missing - registers an offense when splat keyword arg is missing - registers an offense when splat arg is missing - registers an offense when required arg is missing - registers an offense when optional arg is missing - does not register an offense when method call has a receiver other than `self` - registers an offense when arguments are swapped - registers an offense when enumerator is created for `__method__` with missing arguments - registers an offense when enumerator is created for another method - registers an offense when optional keyword arg is missing - ignores the block argument - registers an offense when method is called on `self` - does not register an offense when enumerator is created with `__method__` and the correct arguments - registers an offense when other values are passed for keyword arguments - does not register an offense when enumerator is created with `__callee__` and the correct arguments - arguments forwarding - does not register an offense when enumerator is created with the correct arguments - registers an offense when enumerator is created with non matching arguments +RuboCop::Cop::Style::NonNilCheck + when not allowing semantic changes + does not register an offense with implicit receiver + does not register an offense for not x.nil? + does not register an offense if only expression in class predicate + does not register an offense if only expression in predicate + registers an offense but does not correct when the code was not modified + registers an offense for != nil + does not register an offense for != 0 + does not register an offense if last expression in predicate + does not register an offense if last expression in class predicate + does not register an offense for !x.nil? + when allowing semantic changes + corrects code that would not be modified if IncludeSemanticChanges were false + registers an offense for `not x.nil?` + autocorrects by changing `x != nil` to `x` + does not register an offense for `!x` + registers an offense for unless x.nil? + does not register an offense for `x.nil?` + does not blow up with ternary operators + registers an offense for `!x.nil?` + does not blow up when autocorrecting implicit receiver + when `EnforcedStyle: comparison` of `Style/NilComparison` cop + `IncludeSemanticChanges: false` + does not register an offense for `foo != nil` + `IncludeSemanticChanges: true` + registers an offense for `foo != nil` -RuboCop::Cop::Layout::DotPosition - Trailing dots style - does not err on method call on same line - does not get confused by several lines of chained methods - does not err on method call without a method name - does not err on method call with no dots - accepts trailing dot in multi-line method call - does not err on method call with multi-line arguments - registers an offense for leading dot in multi-line call - when the receiver is a heredoc +RuboCop::Cop::Style::MixinUsage + does not register an offense when using inside nested module + extend + does not register an offense when using inside class + registers an offense when using outside class + prepend + registers an offense when using outside class + does not register an offense when using inside class + include + does not register an offense when using outside class + registers an offense when using outside class (used above) + registers an offense when using `include` in method definition outside class or module + does not register an offense when using inside class + does not register an offense when using `include` in method definition inside module + registers an offense when using outside class (used below) + does not register an offense when using inside block + registers an offense when using only `include` statement + does not register an offense when using `include` in method definition inside class + doesn't register an offense when `include` call is a method argument + does not register an offense when using inside block and `if` condition is after `include` + Nested module + registers an offense when using outside class + Multiple definition classes in one + does not register an offense when using inside class + +RuboCop::ResultCache + #save + when the @path is not writable + behaves like invalid cache location + doesn't raise an exception + behaves like invalid cache location + doesn't raise an exception + when the default internal encoding is UTF-8 + writes non UTF-8 encodable data to file with no exception + .cleanup + removes the oldest files in the cache if needed + the cache path + when CacheRootDirectory is set + contains the given root + and RUBOCOP_CACHE_ROOT is set + contains the root from RUBOCOP_CACHE_ROOT + when CacheRootDirectory not set + and XDG_CACHE_HOME is set + contains the given path and UID + and XDG_CACHE_HOME is not set + contains $HOME/.cache + cached result that was saved with no command line option + when no option is given + is valid and can be loaded + when end of line characters have changed + is invalid + when file permission have changed + is invalid + when a symlink is present in the cache location + and symlink attack protection is disabled + permits caching and prints no warning + and symlink attack protection is enabled + prevents caching and prints a warning + when team external_dependency_checksum is the same + is valid + when file contents have changed + is invalid + when team external_dependency_checksum changes + is invalid + when --format is given + is valid and can be loaded + when --cache-root is given + takes the cache_root from the options + when a cache source is read + has utf8 encoding + when --only is given + is invalid + when --display-cop-names is given + is invalid + when offenses are saved + an offense with status uncorrected + serializes them with uncorrected status + an offense with status unsupported + serializes them with unsupported status + an offense with status new_status + serializes them with new_status status + an offense with status corrected + serializes them with uncorrected status + an offense with status corrected_with_todo + serializes them with uncorrected status + +RuboCop::Cop::Style::TernaryParentheses + when configured to enforce parentheses inclusion + with a complex condition + registers an offense for defined? with method chain in condition + registers an offense for equality check + registers an offense for negated condition + registers an offense for boolean expression containing parens + registers an offense for defined? with nested constant in condition + registers an offense for boolean expression + registers an offense for defined? with variable in condition + registers an offense for arithmetic condition + registers an offense when calling method on a receiver + registers an offense for defined? with class method in condition + registers an offense for boolean expression using keyword + with an assignment condition + accepts safe assignment in condition + registers an offense for triple assignment + registers an offense for double assignment with equality check in condition + registers an offense for double assignment + with a simple condition + registers an offense for accessor in condition + registers an offense for yield in condition + registers an offense for query method in condition + configured for parentheses on complex and there are parens + accepts condition including a range + with an assignment condition + accepts accepts safe multiple assignment + accepts safe assignment + accepts safe assignment as part of multiple assignment + accepts equality check + behaves like safe assignment disabled + registers an offense for parens around outer assignment + registers an offense for parens around inner assignment + registers an offense for parens around assignment + with method call condition + registers an offense for defined check + registers an offense when calling method on a receiver + registers an offense when calling method with a parameter + without accessor in method call parameters + registers an offense for array include? without parens + registers an offense for array include? with parens + with accessor in method call parameters + registers an offense for array include? with multiple parameters without parens + registers an offense for array include? without parens + registers an offense for array include? with multiple parameters with parens + with a simple condition + registers an offense for yield in condition + registers an offense for save navigation + registers an offense for query method in condition + registers an offense with preceding boolean keyword expression + registers an offense for accessor in condition + with a complex condition + accepts boolean expression + registers an offense for defined with nested constant in condition + registers an offense for defined with method chain in condition + registers an offense when calling method on a receiver + accepts boolean expression using keywords + registers an offense for defined with class method in condition + registers an offense for defined with variable in condition + configured for parentheses on complex and there are no parens + with an assignment condition + accepts safe assignment + registers an offense for equality check + with complex condition + registers an offense comparison with exponentiation + registers an offense for boolean expression with inner parens + registers an offense for comparison with multiplication + registers an offense for compound boolean expression + registers an offense for addition expression + registers an offense for comparison with method call on receiver + registers an offense for comparison + registers an offense for arithmetic and equality check + registers an offense for boolean expression + registers an offense for subtraction expression + when configured to enforce parentheses omission + accepts condition including a range + with a simple condition + registers an offense for query method in condition + registers an offense for multi-line boolean expression + registers an offense for yield in condition + registers an offense for accessor in condition + accepts multi-line boolean expression starting on following line + with an assignment condition + accepts double safe assignment + accepts safe assignment + accepts safe assignment as part of multiple assignment + registers an offense for equality check + behaves like safe assignment disabled + registers an offense for parens around inner assignment + registers an offense for parens around assignment + registers an offense for parens around outer assignment + with no space between the parentheses and question mark registers an offense - when there is a heredoc with a following method - does not register an offense for a heredoc - when the receiver has a heredoc argument - with another method on the same line - does not register an offense - with multiple heredocs - registers an offense - with a dynamic heredoc - registers an offense - as the first argument - registers an offense - as the last argument - registers an offense - when using safe navigation operator - accepts trailing dot in multi-line method call - registers an offense for correct + opposite - Leading dots style - registers an offense for only dot line - registers an offense for trailing dot in multi-line call - registers an offense for correct + opposite - accepts leading do in multi-line method call - does not err on method call without a method name - does not err on method call on same line - does not err on method call with no dots - when there is an intervening line comment - does not register offense - when there is an intervening blank line - does not register offense - when the receiver has a heredoc argument - with a dynamic heredoc + with one line pattern matching + does not register an offense + with a complex condition + registers an offense for negated condition + registers an offense for boolean expression + registers an offense for equality check + registers an offense for defined with variable in condition + accepts parens around inner boolean expression + registers an offense for defined with class method in condition + registers an offense for defined with nested constant in condition + registers an offense for query method on object + registers an offense for defined with method chain in condition + registers an offense for boolean expression using keyword + registers an offense for arithmetic expression + with one line pattern matching + does not register an offense + with an unparenthesized method call condition + registers an offense for defined check + registers an offense when calling method with a parameter + when calling method on a constant receiver registers an offense - with multiple heredocs + when calling method on a literal receiver registers an offense - with another method on the same line - does not register an offense - as the last argument + when calling method on a receiver registers an offense - as the first argument + when calling method with multiple arguments registers an offense - when using safe navigation operator - accepts leading do in multi-line method call - registers an offense for correct + opposite - when a method spans multiple lines - registers an offense - with multiple offenses - registers all of them - when the receiver is a heredoc - registers an offense - -RuboCop::Cop::Style::Next - allows super nodes - does not crash with an empty body branch - handles nested autocorrections - allows empty blocks - handles `then` when autocorrecting - does not blow up on empty body while block - does not crash with empty brackets - does not blow up on empty body for block - keeps comments when autocorrecting - doesn't reindent heredoc bodies when autocorrecting - allows loops with conditions at the end with ternary op - does not blow up on empty body until block - MinBodyLength: 3 - accepts if whose body has 1 line - Invalid MinBodyLength - fails with an error - behaves like iterators - registers an offense for unless inside of each - registers an offense for unless inside of for - allows loops with conditional break - registers an offense for unless inside of times - allows loops with unless with else, nested in another condition - registers an offense when line break before condition - registers an offense for unless inside of each_with_object - registers an offense for unless inside of downto - reports an offense for unless whose body has 3 lines - registers an offense for unless inside of nested iterators - autocorrects a misaligned end - allows loops with unless with else at the end - registers an offense for unless inside of select - registers an offense for unless inside of select! - registers an offense for unless inside of reject - allows loops with conditional return - registers an offense for unless inside of collect - registers an offense for unless inside of map - registers an offense for unless inside of nested iterators - registers an offense for a condition at the end of an iterator when there is more in the iterator than the condition - registers an offense for unless inside of reject! - allows loops with unless being the entire body with else - registers an offense for unless inside of loop - EnforcedStyle: always - registers an offense for modifier unless - Ruby 2.7 - registers an offense for unless inside of downto numblock - EnforcedStyle: skip_modifier_ifs - allows modifier unless - behaves like iterators - registers an offense for if inside of nested iterators - registers an offense for if inside of times - registers an offense for if inside of loop - registers an offense for if inside of nested iterators - registers an offense for if inside of reject - registers an offense for if inside of select! - allows loops with conditional break - registers an offense for if inside of reject! - autocorrects a misaligned end - allows loops with if with else, nested in another condition - allows loops with if with else at the end - reports an offense for if whose body has 3 lines - allows loops with conditional return - registers an offense for if inside of each_with_object - allows loops with if being the entire body with else - registers an offense for a condition at the end of an iterator when there is more in the iterator than the condition - registers an offense for if inside of for - registers an offense for if inside of select - registers an offense for if inside of downto - registers an offense for if inside of each - registers an offense for if inside of map - registers an offense for if inside of collect - registers an offense when line break before condition - EnforcedStyle: skip_modifier_ifs - allows modifier if - Ruby 2.7 - registers an offense for if inside of downto numblock - EnforcedStyle: always - registers an offense for modifier if - -RuboCop::Cop::Lint::RedundantDirGlobSort - does not register an offense when using `sort` without a receiver - does not register an offense when not using `sort` for `Dir` - when Ruby 3.0 or higher - does not register an offense when not using `sort` with `sort: false` option for `Dir` - registers an offense and correction when using `::Dir.glob.sort` - does not register an offense when using `Dir.glob('./b/*.txt', './a/*.txt').sort` - does not register an offense when using `Dir[*path].sort` - does not register an offense when using `Dir.glob(*path).sort` - registers an offense and correction when using `Dir.glob.sort` - registers an offense and correction when using `Dir[].sort.each(&do_something)` - does not register an offense when using `Dir['./b/*.txt', './a/*.txt'].sort` - does not register an offense when using `collection.sort` - registers an offense and correction when using `Dir[].sort.each do` - when Ruby 2.7 or lower - does not register an offense and correction when using `Dir[].sort.each(&do_something)` - does not register an offense and correction when using `::Dir.glob.sort` - does not register an offense and correction when using `Dir.glob.sort` - does not register an offense and correction when using `Dir[].sort.each do` -RuboCop::Cop::Style::RedundantInterpolation - registers an offense for "#{@@var}" - registers an offense for "#{1 + 1; 2 + 2}" - registers an offense for "%Q(#{1 + 1})" - registers an offense for "#{var}" - registers an offense for "%|#{1 + 1}|" - registers an offense for "#{do_something 42}" - registers an offense for "#{$+}" - registers an offense for "#$+" - registers an offense for "#{$1}" - registers an offense for "#$1" - registers an offense for "#{1 + 1}" - registers an offense for "#$var" - accepts strings that are part of a %W() - registers an offense for ["#{@var}"] - accepts strings with characters before the interpolation - registers an offense for "#{foo.do_something 42}" - registers an offense for "#{$var}" - accepts strings implicitly concatenated with an earlier string - accepts strings with characters after the interpolation - registers an offense for "#@@var" - registers an offense for "#{number}" - registers an offense for "#{do_something(42)}" - registers an offense for "#@var" - registers an offense for "#{@var}" - accepts strings implicitly concatenated with a later string +RuboCop::Cop::Lint::DuplicateBranch + does not register an offense for empty `if` + does not register an offense for modifier `if` + registers an offense when `rescue` has multiple duplicate `resbody` branches + registers an offense when `rescue` has duplicate `resbody` branch + does not register an offense when `case` has no duplicate branches + does not register an offense for simple `unless` without other branches + registers an offense when ternary has duplicate branches + registers an offense when `case` has duplicate `else` branch + does not register an offense for modifier `unless` + does not register an offense when `rescue` has no duplicate branches + registers an offense when `if` has duplicate `else` branch + registers an offense when `if` has duplicate `elsif` branch + registers an offense when `case` has duplicate `when` branch + registers an offense when `unless` has duplicate `else` branch + registers an offense when `case` has multiple duplicate branches + registers an offense when `if` has multiple duplicate branches + does not register an offense when `unless` has no duplicate branches + does not register an offense for empty `unless` + does not register an offense when `if` has no duplicate branches + does not register an offense for simple `if` without other branches + registers an offense when `rescue` has duplicate `else` branch + does not register an offense when ternary has no duplicate branches + with IgnoreLiteralBranches: true + with `if` + behaves like literal if allowed + when returning a nil in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a array of literals in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a rational in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a float in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a empty hash in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a symbol in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a complex hash in multiple branches + registers an offense + behaves like literal if allowed + when returning a hash of literals in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a complex in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a method call in multiple branches + registers an offense + behaves like literal if allowed + when returning a regexp in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a integer in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a true in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a complex erange in multiple branches + registers an offense + behaves like literal if disallowed + when returning a complex irange in multiple branches + registers an offense + behaves like literal if allowed + when returning a regexp with modifier in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a simple irange in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a dsym in multiple branches + registers an offense + and IgnoreConstBranches: true + behaves like literal if allowed + when returning a hash of constants in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a array of constants in multiple branches + allows branches to be duplicated + behaves like literal if allowed + when returning a simple erange in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a variable in multiple branches + registers an offense + behaves like literal if allowed + when returning a empty array in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a xstr in multiple branches + registers an offense + behaves like literal if allowed + when returning a false in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a dstr in multiple branches + registers an offense + and IgnoreConstBranches: false + behaves like literal if disallowed + when returning a array of constants in multiple branches + registers an offense + behaves like literal if disallowed + when returning a hash of constants in multiple branches + registers an offense + behaves like literal if disallowed + when returning a complex array in multiple branches + registers an offense + behaves like literal if disallowed + when returning a complex regexp in multiple branches + registers an offense + behaves like literal if allowed + when returning a string in multiple branches + allows branches to be duplicated + with `rescue` + and IgnoreConstBranches: false + behaves like literal rescue disallowed + when returning a array of constants in multiple branches + registers an offense + behaves like literal rescue disallowed + when returning a hash of constants in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a symbol in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a empty array in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a hash of literals in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a dstr in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a nil in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a true in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a simple irange in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a regexp with modifier in multiple branches + allows branches to be duplicated + and IgnoreConstBranches: true + behaves like literal rescue allowed + when returning a hash of constants in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a array of constants in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a complex in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a dsym in multiple branches + registers an offense + behaves like literal rescue disallowed + when returning a method call in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a simple erange in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a regexp in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a variable in multiple branches + registers an offense + behaves like literal rescue disallowed + when returning a complex erange in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a string in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a complex irange in multiple branches + registers an offense + behaves like literal rescue disallowed + when returning a xstr in multiple branches + registers an offense + behaves like literal rescue disallowed + when returning a complex regexp in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a empty hash in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a rational in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a array of literals in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a integer in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a complex hash in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a float in multiple branches + allows branches to be duplicated + behaves like literal rescue allowed + when returning a false in multiple branches + allows branches to be duplicated + behaves like literal rescue disallowed + when returning a complex array in multiple branches + registers an offense + with `case` + behaves like literal case disallowed + when returning a method call in multiple branches + registers an offense + behaves like literal case allowed + when returning a simple irange in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a string in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a complex array in multiple branches + registers an offense + and IgnoreConstBranches: false + behaves like literal case disallowed + when returning a array of constants in multiple branches + registers an offense + behaves like literal case disallowed + when returning a hash of constants in multiple branches + registers an offense + behaves like literal case disallowed + when returning a variable in multiple branches + registers an offense + behaves like literal case allowed + when returning a complex in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a true in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a symbol in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a complex regexp in multiple branches + registers an offense + behaves like literal case allowed + when returning a simple erange in multiple branches + allows branches to be duplicated + and IgnoreConstBranches: true + behaves like literal case allowed + when returning a array of constants in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a hash of constants in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a xstr in multiple branches + registers an offense + behaves like literal case allowed + when returning a rational in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a nil in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a complex irange in multiple branches + registers an offense + behaves like literal case allowed + when returning a regexp in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a false in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a empty array in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a complex erange in multiple branches + registers an offense + behaves like literal case allowed + when returning a empty hash in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a dsym in multiple branches + registers an offense + behaves like literal case disallowed + when returning a dstr in multiple branches + registers an offense + behaves like literal case allowed + when returning a array of literals in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a hash of literals in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a float in multiple branches + allows branches to be duplicated + behaves like literal case allowed + when returning a integer in multiple branches + allows branches to be duplicated + behaves like literal case disallowed + when returning a complex hash in multiple branches + registers an offense + behaves like literal case allowed + when returning a regexp with modifier in multiple branches + allows branches to be duplicated + with IgnoreConstantBranches: true + with `if` + behaves like literal if allowed + when returning a constant in multiple branches + allows branches to be duplicated + behaves like literal if disallowed + when returning a object in multiple branches + registers an offense + with `case` + behaves like literal case disallowed + when returning a object in multiple branches + registers an offense + behaves like literal case allowed + when returning a constant in multiple branches + allows branches to be duplicated + with `case-match` + behaves like literal case-match disallowed + when returning a object in multiple branches + registers an offense + behaves like literal case-match allowed + when returning a constant in multiple branches + allows branches to be duplicated + with `rescue` + behaves like literal rescue disallowed + when returning a object in multiple branches + registers an offense + behaves like literal rescue allowed + when returning a constant in multiple branches + allows branches to be duplicated RuboCop::Cop::Lint::DuplicateCaseCondition accepts trivial case expressions accepts non-redundant case expressions registers an offense for repeated logical operator when expressions registers multiple offenses for repeated multi-value conditionals - accepts similar but not equivalent && expressions registers an offense for repeated case conditionals - registers multiple offenses for multiple repeated case conditionals - registers an offense for subsequent repeated case conditionals accepts non-redundant case expressions with an else expression - -RuboCop::Cop::Layout::RedundantLineBreak - when InspectBlocks is true - for an expression that fits on a single line - registers an offense for a method call with a double quoted split string in parentheses - registers an offense for a method call with a split operation - accepts an assignment containing an if expression - accepts a method call on a single line - registers an offense for a method call on multiple lines with backslash - accepts an assignment containing a begin-end expression - registers an offense for a method call on multiple lines - accepts an assignment containing a case expression - registers an offense for a method call with a double and single quoted split string - accepts a binary expression containing an if expression - registers an offense for a method call as right hand side of an assignment - registers an offense for a method call on multiple lines inside a block - accepts a method call with a block - registers an offense for a method call with a double quoted split string without parentheses - registers an offense for a method call with a single quoted split string - accepts a method call on multiple lines if there are comments on them - with LineLength Max 100 - registers an offense for a method without parentheses on multiple lines - method chains - properly corrects a method chain on multiple lines - does not register an offense with a heredoc argument - registers an offense and corrects with a string argument on multiple lines - registers an offense and corrects with a arguments on multiple lines - when Layout/SingleLineBlockChain is disabled - reports an offense for a method call chained onto a single line block - when Layout/SingleLineBlockChain is enabled - accepts a method call chained onto a single line block - for an expression that does not fit on a single line - accepts a method call on a multiple lines - with a longer max line length - registers an offense for a method call with a do keyword that is just under the max line length - accepts an assignment containing a method definition - accepts a method call followed by binary operations that are too long taken together - accepts a complex method call on a multiple lines - accepts method call with a do keyword that would just surpass the max line length - accepts an assignment containing a heredoc - for a block - accepts when it is difficult to convert to single line - for a block - registers an offense when the method call has no arguments - registers an offense when the method call has parentheses - when Layout/SingleLineBlockChain is disabled - reports an offense for a method call chained onto a multiline block - reports an offense for a multiline block without a chained method call - when Layout/SingleLineBlockChain is enabled - reports an offense for a multiline block without a chained method call - when InspectBlocks is false - when Layout/SingleLineBlockChain is disabled - reports an offense for a method call chained onto a single line block - when Layout/SingleLineBlockChain is enabled - accepts a method call chained onto a single line block - for an expression that fits on a single line - accepts a binary expression containing an if expression - registers an offense for a method call with a split operation - registers an offense for a method call with a double and single quoted split string - accepts an assignment containing a begin-end expression - accepts a method call with a block - registers an offense for a method call with a double quoted split string in parentheses - accepts an assignment containing a case expression - accepts an assignment containing an if expression - registers an offense for a method call with a single quoted split string - accepts a method call on a single line - registers an offense for a method call as right hand side of an assignment - registers an offense for a method call on multiple lines with backslash - registers an offense for a method call with a double quoted split string without parentheses - registers an offense for a method call on multiple lines inside a block - accepts a method call on multiple lines if there are comments on them - registers an offense for a method call on multiple lines - with LineLength Max 100 - registers an offense for a method without parentheses on multiple lines - method chains - registers an offense and corrects with a arguments on multiple lines - registers an offense and corrects with a string argument on multiple lines - properly corrects a method chain on multiple lines - does not register an offense with a heredoc argument - for an expression that does not fit on a single line - accepts a method call on a multiple lines - with a longer max line length - registers an offense for a method call with a do keyword that is just under the max line length - accepts an assignment containing a method definition - accepts a complex method call on a multiple lines - accepts a method call followed by binary operations that are too long taken together - accepts an assignment containing a heredoc - accepts method call with a do keyword that would just surpass the max line length - for a block - accepts when it is difficult to convert to single line - for a block - accepts when the method call has parentheses - accepts when the method call has no arguments - when Layout/SingleLineBlockChain is enabled - accepts a multiline block without a chained method call - when Layout/SingleLineBlockChain is disabled - accepts a multiline block without a chained method call - accepts a method call chained onto a multiline block - -RuboCop::MagicComment - returns nil for encoding when comment is # shareable_constant_value: experimental_copy - returns nil for frozen_string_literal when comment is # incoding: utf-8 - returns nil for shareable_constant_value when comment is # frozen-string-literal: true - returns nil for encoding when comment is # FROZEN-STRING-LITERAL: true - returns nil for shareable_constant_value when comment is # typed: strong - returns nil for shareable_constant_value when comment is # incoding: utf-8 - returns true for frozen_string_literal when comment is # FROZEN-STRING-LITERAL: true - returns nil for shareable_constant_value when comment is # frozen_string_literal: true - returns nil for shareable_constant_value when comment is # xyz shareable_constant_value: literal - returns "strong" for typed when comment is # typed: strong - returns true for frozen_string_literal when comment is # -*- frozen-string-literal: true -*- - returns nil for encoding when comment is # @typed - returns nil for frozen_string_literal when comment is # eNcOdInG: utf-8 - returns nil for encoding when comment is # vim: filetype=ruby,fileencoding=ascii-8bit - returns nil for encoding when comment is # frozen-string-literal: true - returns nil for typed when comment is # encoding: ascii-8bit frozen_string_literal: true - returns nil for encoding when comment is #typed:strict - returns true for frozen_string_literal when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for typed when comment is # encoding: utf-8 - returns nil for typed when comment is # -*- coding: ASCII-8BIT; typed: strict -*- - returns nil for frozen_string_literal when comment is # coding: utf-8 - returns nil for typed when comment is # -*- encoding : ascii-8bit -*- - returns nil for encoding when comment is # - returns nil for frozen_string_literal when comment is # typed: false - returns nil for frozen_string_literal when comment is # - returns nil for encoding when comment is # typed: strong - returns nil for typed when comment is # frozen_string_literal: invalid - returns true for frozen_string_literal when comment is # frozen_string_literal: true - returns "ascii-8bit" for encoding when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for typed when comment is # @typed - returns nil for typed when comment is # vim: filetype=python, fileencoding=ascii-8bit - returns true for frozen_string_literal when comment is # frozen_string_literal:true - returns nil for frozen_string_literal when comment is #typed:strict - returns nil for typed when comment is # ENCODING: utf-8 - returns nil for shareable_constant_value when comment is # encoding: stateless-iso-2022-jp-kddi - returns nil for frozen_string_literal when comment is # shareable_constant_value: experimental_everything - returns "ascii-8bit" for encoding when comment is # encoding: ascii-8bit frozen_string_literal: true - returns nil for shareable_constant_value when comment is # encoding: utf-8 - returns nil for frozen_string_literal when comment is # vim: filetype=ruby,fileencoding=ascii-8bit - returns nil for frozen_string_literal when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for typed when comment is # - returns nil for shareable_constant_value when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for typed when comment is # coding: utf-8 - returns nil for shareable_constant_value when comment is # ENCODING: utf-8 - returns nil for typed when comment is # vim: filetype=ruby,fileencoding=ascii-8bit - returns "ascii-8bit" for encoding when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns "utf-8" for encoding when comment is # coding: utf-8 - returns nil for shareable_constant_value when comment is # typed: true - returns "utf-8" for encoding when comment is # eNcOdInG: utf-8 - returns nil for typed when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| - returns "utf-8" for encoding when comment is # encoding: utf-8 - returns nil for encoding when comment is # typed: true - returns nil for frozen_string_literal when comment is # shareable_constant_value:literal - returns nil for frozen_string_literal when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for shareable_constant_value when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for encoding when comment is # xyz shareable_constant_value: literal - returns nil for shareable_constant_value when comment is # - returns "ascii-8bit" for encoding when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns "false" for typed when comment is # typed: false - returns nil for encoding when comment is # fRoZeN-sTrInG_lItErAl: true - returns nil for typed when comment is # frozen_string_literal:true - returns nil for shareable_constant_value when comment is # vim: filetype=ruby,fileencoding=ascii-8bit - returns "none" for shareable_constant_value when comment is # shareable_constant_value: none - returns nil for shareable_constant_value when comment is # eNcOdInG: utf-8 - returns "ascii-8bit" for encoding when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict - returns "experimental_copy" for shareable_constant_value when comment is # shareable_constant_value: experimental_copy - returns nil for encoding when comment is # typed: false - returns nil for typed when comment is # FROZEN-STRING-LITERAL: true - returns "ascii-8bit" for encoding when comment is # -*- encoding : ascii-8bit -*- - returns nil for shareable_constant_value when comment is #vim: filetype=ruby, fileencoding=ascii-8bit - returns "ignore" for typed when comment is # typed: ignore - returns nil for typed when comment is # -*- frozen-string-literal: true -*- - returns "strict" for typed when comment is # typed:strict - returns nil for frozen_string_literal when comment is # sHaReaBLE-CoNstANT-ValUE: literal - returns nil for typed when comment is # shareable_constant_value: literal - returns nil for shareable_constant_value when comment is # vim: filetype=python, fileencoding=ascii-8bit - returns nil for typed when comment is # frozen_string_literal: true - returns "ascii-8bit" for encoding when comment is # -*- coding: ASCII-8BIT; typed: strict -*- - returns nil for shareable_constant_value when comment is # coding: utf-8 - returns nil for shareable_constant_value when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for frozen_string_literal when comment is # typed:strict - returns nil for frozen_string_literal when comment is # @typed - returns nil for shareable_constant_value when comment is # -*- frozen-string-literal: true -*- - returns nil for typed when comment is # fRoZeN-sTrInG_lItErAl: true - returns nil for typed when comment is # frozen_string_literal: true encoding: ascii-8bit - returns nil for encoding when comment is # vim:fileencoding=utf-8 - returns nil for encoding when comment is # xyz shareable_constant_value: literal xyz - returns nil for frozen_string_literal when comment is # coding: utf-8 - returns nil for typed when comment is # -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for shareable_constant_value when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for frozen_string_literal when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict - returns nil for encoding when comment is # frozen_string_literal: true - returns nil for typed when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for typed when comment is # frozen_string_literal: true - returns nil for frozen_string_literal when comment is # ENCODING: utf-8 - returns nil for typed when comment is # frozen_string_literal: false - returns nil for frozen_string_literal when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| - returns nil for shareable_constant_value when comment is # -*- encoding : ascii-8bit -*- - returns true for frozen_string_literal when comment is # fRoZeN-sTrInG_lItErAl: true - returns nil for shareable_constant_value when comment is # coding: utf-8 - returns nil for frozen_string_literal when comment is #vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for shareable_constant_value when comment is # @typed - returns nil for frozen_string_literal when comment is # typed: strict - returns "ascii-8bit" for encoding when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for shareable_constant_value when comment is # typed: strict - returns nil for shareable_constant_value when comment is # typed:strict - returns "strict" for typed when comment is #typed:strict - returns nil for typed when comment is # shareable_constant_value: none - returns nil for frozen_string_literal when comment is # vim:fileencoding=utf-8 - returns "strict" for typed when comment is # typed: strict - returns nil for shareable_constant_value when comment is # frozen_string_literal: false - returns nil for encoding when comment is # typed:strict - returns nil for typed when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict - returns true for frozen_string_literal when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for shareable_constant_value when comment is #typed:strict - returns nil for shareable_constant_value when comment is #vim: filetype=ruby, fileencoding=ascii-8bit, typed=strict - returns "ascii-8bit" for encoding when comment is # frozen_string_literal: true encoding: ascii-8bit - returns nil for frozen_string_literal when comment is # encoding: utf-8 - returns "literal" for shareable_constant_value when comment is # shareable-constant-value: literal - returns nil for frozen_string_literal when comment is # xyz shareable_constant_value: literal - returns nil for shareable_constant_value when comment is # fRoZeN-sTrInG_lItErAl: true - returns nil for encoding when comment is # shareable-constant-value: literal - returns nil for encoding when comment is # shareable_constant_value: literal - returns nil for frozen_string_literal when comment is # typed: strong - returns nil for frozen_string_literal when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for shareable_constant_value when comment is # FROZEN-STRING-LITERAL: true - returns nil for typed when comment is # vim:fileencoding=utf-8 - returns "literal" for shareable_constant_value when comment is # sHaReaBLE-CoNstANT-ValUE: literal - returns nil for typed when comment is #vim: filetype=ruby, fileencoding=ascii-8bit - returns "literal" for shareable_constant_value when comment is # shareable_constant_value:literal - returns nil for shareable_constant_value when comment is # vim:fileencoding=utf-8 - returns nil for frozen_string_literal when comment is # typed: true - returns nil for shareable_constant_value when comment is # frozen_string_literal: true encoding: ascii-8bit - returns nil for shareable_constant_value when comment is # frozen_string_literal:true - returns nil for typed when comment is # shareable_constant_value:literal - returns nil for typed when comment is # xyz shareable_constant_value: literal - returns "true" for typed when comment is # typed: true - returns nil for frozen_string_literal when comment is # shareable_constant_value: experimental_copy - returns nil for encoding when comment is # incoding: utf-8 - returns nil for shareable_constant_value when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| - returns nil for encoding when comment is # sHaReaBLE-CoNstANT-ValUE: literal - returns "ascii-8bit" for encoding when comment is # vim: filetype=python, fileencoding=ascii-8bit - returns nil for typed when comment is # encoding: stateless-iso-2022-jp-kddi - returns nil for frozen_string_literal when comment is # shareable-constant-value: literal - returns nil for typed when comment is # sHaReaBLE-CoNstANT-ValUE: literal - returns nil for frozen_string_literal when comment is # encoding: stateless-iso-2022-jp-kddi - returns "stateless-iso-2022-jp-kddi" for encoding when comment is # encoding: stateless-iso-2022-jp-kddi - returns nil for frozen_string_literal when comment is # -*- coding: ASCII-8BIT; typed: strict -*- - returns nil for frozen_string_literal when comment is # SHAREABLE-CONSTANT-VALUE: literal - returns "utf-8" for encoding when comment is # coding: utf-8 vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for shareable_constant_value when comment is # typed: false - returns nil for frozen_string_literal when comment is # vim: filetype=python, fileencoding=ascii-8bit - returns nil for typed when comment is # incoding: utf-8 - returns true for frozen_string_literal when comment is # frozen_string_literal: true - returns "experimental_everything" for shareable_constant_value when comment is # shareable_constant_value: experimental_everything - returns nil for frozen_string_literal when comment is # -*- encoding : ascii-8bit -*- - returns nil for shareable_constant_value when comment is # typed: ignore - returns nil for encoding when comment is # typed: ignore - returns nil for shareable_constant_value when comment is # frozen_string_literal: invalid - returns nil for frozen_string_literal when comment is # shareable_constant_value: literal - returns nil for shareable_constant_value when comment is # -*- coding: ASCII-8BIT; typed: strict -*- - returns nil for typed when comment is # coding: utf-8 - returns nil for frozen_string_literal when comment is # shareable_constant_value: none - returns "utf-8" for encoding when comment is # ENCODING: utf-8 - returns "ascii-8bit" for encoding when comment is #vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for encoding when comment is # shareable_constant_value: none - returns nil for typed when comment is # shareable_constant_value: experimental_copy - returns "invalid" for frozen_string_literal when comment is # frozen_string_literal: invalid - returns "utf-8" for encoding when comment is # coding: utf-8 - returns nil for shareable_constant_value when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns nil for typed when comment is # frozen-string-literal: true - returns nil for encoding when comment is # SHAREABLE-CONSTANT-VALUE: literal - returns nil for encoding when comment is CSV.generate(encoding: Encoding::UTF_8) do |csv| - returns nil for encoding when comment is # frozen_string_literal: true - returns nil for typed when comment is # xyz shareable_constant_value: literal xyz - returns nil for frozen_string_literal when comment is # typed: ignore - returns false for frozen_string_literal when comment is # frozen_string_literal: false - returns nil for shareable_constant_value when comment is # frozen_string_literal: true - returns nil for typed when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns "literal" for shareable_constant_value when comment is # SHAREABLE-CONSTANT-VALUE: literal - returns nil for encoding when comment is # -*- frozen-string-literal: true -*- - returns nil for frozen_string_literal when comment is # frozen_string_literal: true encoding: ascii-8bit - returns nil for encoding when comment is # frozen_string_literal: invalid - returns nil for shareable_constant_value when comment is # encoding: ascii-8bit frozen_string_literal: true - returns nil for frozen_string_literal when comment is # xyz shareable_constant_value: literal xyz - returns nil for encoding when comment is # shareable_constant_value:literal - returns nil for encoding when comment is # frozen_string_literal: false - returns nil for typed when comment is # shareable-constant-value: literal - returns nil for typed when comment is # shareable_constant_value: experimental_everything - returns nil for encoding when comment is # typed: strict - returns "literal" for shareable_constant_value when comment is # shareable_constant_value: literal - returns nil for frozen_string_literal when comment is # encoding: ascii-8bit frozen_string_literal: true - returns nil for encoding when comment is # frozen_string_literal:true - returns nil for typed when comment is # vim: filetype=ruby, fileencoding=ascii-8bit - returns true for frozen_string_literal when comment is # frozen-string-literal: true - returns nil for shareable_constant_value when comment is # xyz shareable_constant_value: literal xyz - returns nil for typed when comment is # coding: utf-8 -*- encoding: ASCII-8BIT; frozen_string_literal: true -*- - returns nil for encoding when comment is # shareable_constant_value: experimental_everything - returns nil for typed when comment is # eNcOdInG: utf-8 - returns nil for typed when comment is # SHAREABLE-CONSTANT-VALUE: literal - #valid? - with an frozen string literal comment - is expected to equal true - with an encoding comment - is expected to equal true - with a non magic comment - is expected to equal false - with an empty string - is expected to equal false - with an shareable constant value comment - is expected to equal true - #valid_shareable_constant_value? - when given comment specified as `literal` - is expected to equal true - when given comment is not specified - is expected to equal false - when given comment specified as `experimental_copy` - is expected to equal true - when given comment specified as `none` - is expected to equal true - when given comment specified as unknown value - is expected to equal false - when given comment specified as `experimental_everything` - is expected to equal true - #without - simple format - when the comment contains a different magic value - is expected to eq "# frozen-string-literal: true" - when the entire comment is a single value - is expected to eq "" - vim format - when the comment has multiple tokens - is expected to eq "# vim: filetype=ruby" - emacs format - with one token - is expected to eq "" - with multiple tokens - is expected to eq "# -*- frozen_string_literal: true -*-" - -RuboCop::Cop::Style::TrailingMethodEndStatement - autocorrects all trailing ends for larger example - register offense with trailing end on method with comment - register offense with trailing end on 2 line method - does not register on single line no op - register offense with trailing end inside class - register offense with trailing end on 3 line method - register offense with trailing end on method with block - does not register on single line method - when Ruby 3.0 or higher - does not register an offense when using endless method definition - does not register an offense when endless method definition signature and body are on different lines - -RuboCop::Cop::Style::MethodCalledOnDoEndBlock - with a single-line do..end block - registers an offense for a chained call - accepts a single-line do..end block with a chained block - with a {} block - accepts a single-line block with a chained call - accepts a multi-line block with a chained call - with a multi-line do..end block - registers an offense for a chained call - accepts it if there is no chained call - accepts a chained block - when using safe navigation operator - registers an offense for a chained call - Ruby 2.7 - registers an offense for a chained call - -RuboCop::Cop::Style::HashAsLastArrayItem - when EnforcedStyle is no_braces - does not register an offense when the array is all hashes - does not register an offense when hash is not inside array - registers an offense and corrects when hash with braces and trailing comma and new line - does not register an offense when the hash is empty - registers an offense and corrects when hash with braces and trailing comma - registers an offense and corrects when hash with braces - does not register an offense when passing an implicit array to a setter - does not register an offense when hash is not the last element - does not register an offense when hash without braces - when EnforcedStyle is braces - does not register an offense when the array is all hashes - does not register an offense when the hash is empty - does not register an offense when hash with braces - does not register an offense when hash is not inside array - registers an offense and corrects when hash without braces - does not register an offense when using double splat operator - -RuboCop::Cop::AnnotationComment - #annotation? - when annotated with a non keyword - is expected to be falsey - when the keyword is not capitalized properly - is expected to equal true - when the keyword is multiple words - is expected to equal true - when given a keyword followed by a colon - is expected to equal true - when given as the first word of a sentence - is expected to be falsey - when it includes a keyword - is expected to be falsey - when given a keyword followed by a space - is expected to equal true - #correct? - when a colon is required - behaves like correct - is expected to be truthy - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - when no colon is required - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - when there is duplication in the keywords - when the shorter keyword is given first - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - when the longer keyword is given first - behaves like incorrect - is expected to be falsey - behaves like correct - is expected to be truthy - behaves like correct - is expected to be truthy - behaves like incorrect - is expected to be falsey - -RuboCop::Cop::Lint::RedundantSplatExpansion - allows expansions of an array that is assigned to a variable in rescue - accepts expanding a variable as a method parameter - allows assigning a variable to a splat expansion of a variable - allows assigning to a splat - allows assigning to a splat variable - allows expanding a method call on an array literal - allows an array using a constructor - allows splat expansion inside of an array - registers an offense and corrects an array literal being expanded in a rescue - allows assigning to an expanded range - assignment to splat expansion - registers an offense and corrects an array using a constructor - registers and corrects an array using top-level const - behaves like array splat expansion - method parameters - registers an offense and converts to a list of arguments - behaves like splat literal assignment - registers an offense and removes the splat from array - splat expansion inside of an array - registers an offense and corrects expansion of %w to a list of words - registers an offense and corrects expansion of %W to a list of words - registers an offense and corrects the expansion of an array literalinside of an array literal - behaves like splat expansion - behaves like splat literal assignment - registers an offense and converts to an array - method parameters - registers an offense and converts to an array - when `AllowPercentLiteralArrayArgument: false` - registers an offense when using percent symbol literal array - registers an offense when using percent literal array - behaves like array splat expansion - method parameters - registers an offense and converts to a list of arguments - behaves like splat literal assignment - registers an offense and removes the splat from array - behaves like array splat expansion - behaves like splat literal assignment - registers an offense and removes the splat from array - method parameters - registers an offense and converts to a list of arguments - behaves like array splat expansion - behaves like splat literal assignment - registers an offense and removes the splat from array - method parameters - registers an offense and converts to a list of arguments - splat expansion of method parameters - registers an offense and corrects an array literal %i - registers an offense and corrects an array literal %I - behaves like array splat expansion - method parameters - registers an offense and converts to a list of arguments - behaves like splat literal assignment - registers an offense and removes the splat from array - expanding Array.new call on method argument - registers an offense and corrects - when `AllowPercentLiteralArrayArgument: true` - does not register an offense when using percent symbol literal array - does not register an offense when using percent string literal array - behaves like splat expansion - behaves like splat literal assignment - registers an offense and converts to an array - method parameters - registers an offense and converts to an array - expanding an array literal in a when condition - allows an array that is assigned to a variable - registers an offense and corrects an array using %w - registers an offense and corrects %i to a list of symbols - registers an offense and corrects %I to a list of symbols - registers an offense and corrects an array using %W - allows an array using a constructor - registers an offense and corrects an array using [] - behaves like splat expansion - method parameters - registers an offense and converts to an array - behaves like splat literal assignment - registers an offense and converts to an array - expanding Array.new call on array literal - when the array literal contains exactly one element - registers an offense and corrects - when the array literal contains more than one element - accepts - with ::Array.new - when the array literal contains exactly one element - registers an offense and corrects - arrays being expanded with %i variants using splat expansion - splat expansion inside of an array - registers an offense and changes %I to a list of symbols - registers an offense and corrects %i to a list of symbols - behaves like splat expansion - method parameters - registers an offense and converts to an array - behaves like splat literal assignment - registers an offense and converts to an array - -RuboCop::Cop::Style::EachWithObject - ignores inject and reduce with empty body - correctly autocorrects with return value only - finds inject and reduce with passed in and returned hash - ignores inject and reduce with condition as body - does not blow up for reduce with no arguments - ignores inject and reduce passed in symbol - ignores inject/reduce with assignment to accumulator param in block - correctly autocorrects - ignores inject and reduce with passed in, but not returned hash - when a simple literal is passed as initial value - ignores inject/reduce - Ruby 2.7 - finds inject and reduce with passed in and returned hash and numblock - -RuboCop::Cop::Style::OperatorMethodCall - does not register an offense when using `foo ** bar` - registers an offense when using `foo.>= bar` - registers an offense when using `foo.^(bar)` - does not register an offense when using `foo == bar` - does not register an offense when using `foo < bar` - registers an offense when chaining `foo.bar./(baz).round(2)` - does not register an offense when using `foo * bar` - registers an offense when using `foo.* bar` - registers an offense when chaining `foo.bar.*(baz).round(2)` - registers an offense when chaining `foo.bar.==(baz).round(2)` - does not register an offense when using `foo.~@bar` - registers an offense when chaining `foo.bar.<<(baz).round(2)` - registers an offense when using `foo.<<(bar)` - does not register an offense when using `foo != bar` - does not register an offense when using `foo.-@bar` - registers an offense when chaining `foo.bar.**(baz).round(2)` - registers an offense when chaining `foo.bar.!(baz).round(2)` - registers an offense when using `foo.>> bar` - registers an offense when using `foo.=~ bar` - registers an offense when using `foo.%(bar)` - does not register an offense when using `foo === bar` - registers an offense when using `foo./ bar` - registers an offense when chaining `foo.bar.=~(baz).round(2)` - does not register an offense when using `foo.+@bar.to_s` - registers an offense when using `foo.< bar` - registers an offense when chaining `foo.bar.^(baz).round(2)` - registers an offense when using `foo.!~(bar)` - registers an offense when using `foo.<< bar` - registers an offense when using `foo.&(bar)` - registers an offense when chaining `foo.bar.!=(baz).round(2)` - registers an offense when using `foo.<(bar)` - registers an offense when using `foo.& bar` - registers an offense when chaining `foo.bar.+(baz).round(2)` - does not register an offense when using `foo.`bar` - registers an offense when chaining `foo.bar.-(baz).round(2)` - registers an offense when chaining `foo.bar.===(baz).round(2)` - registers an offense when using `foo.=~(bar)` - registers an offense when using `foo.!(bar)` - registers an offense when chaining `foo.bar.>>(baz).round(2)` - registers an offense when using `foo.-(bar)` - registers an offense when using `foo.<=>(bar)` - does not register an offense when using `foo !~ bar` - does not register an offense when using `obj.!` - does not register an offense when using `foo.!@bar` - registers an offense when using `foo.- bar` - registers an offense when chaining `foo.bar.&(baz).round(2)` - does not register an offense when using `foo & bar` - registers an offense when using `foo.|(bar)` - registers an offense when chaining `foo.bar.!~(baz).round(2)` - registers an offense when using `foo.~ bar` - registers an offense when using `foo.+ bar` - registers an offense when using `foo.+(bar)` - does not register an offense when using `foo.+@bar` - registers an offense when using `foo.~(bar)` - registers an offense when using `foo.> bar` - does not register an offense when using `foo ~ bar` - registers an offense when using `foo.<=> bar` - registers an offense when using `foo.<= bar` - registers an offense when using `foo.!= bar` - registers an offense when using `foo.** bar` - registers an offense when chaining `foo.bar.>(baz).round(2)` - registers an offense when chaining `foo.bar.<=>(baz).round(2)` - does not register an offense when using `foo =~ bar` - does not register an offense when using `foo << bar` - does not register an offense when using `foo ! bar` - registers an offense when using `foo.===(bar)` - does not register an offense when using `foo >> bar` - registers an offense when using `foo.! bar` - does not register an offense when using `foo / bar` - registers an offense when using `foo.>>(bar)` - does not register an offense when using `foo + bar` - does not register an offense when using `foo > bar` - registers an offense when chaining `foo.bar.~(baz).round(2)` - does not register an offense when using `foo ^ bar` - does not register an offense when using `foo >= bar` - registers an offense when using `foo.!~ bar` - does not register an offense when using `Foo.+(bar)` - does not register an offense when using `foo <= bar` - registers an offense when chaining `foo.bar.>=(baz).round(2)` - registers an offense when using `foo.== bar` - registers an offense when using `foo.>=(bar)` - registers an offense when chaining `foo.bar.<=(baz).round(2)` - does not register an offense when using `foo % bar` - does not register an offense when using `foo | bar` - registers an offense when using `foo.!=(bar)` - registers an offense when using `foo.**(bar)` - registers an offense when using `foo.| bar` - registers an offense when using `foo.=== bar` - registers an offense when chaining `foo.bar.|(baz).round(2)` - registers an offense when using `foo.*(bar)` - does not register an offense when using `foo - bar` - does not register an offense when using `foo <=> bar` - registers an offense when using `foo.==(bar)` - registers an offense when chaining `foo.bar.<(baz).round(2)` - registers an offense when using `foo.<=(bar)` - registers an offense when using `foo.^ bar` - registers an offense when using `foo./(bar)` - registers an offense when using `foo.% bar` - registers an offense when using `foo.>(bar)` - registers an offense when chaining `foo.bar.%(baz).round(2)` - -RuboCop::Cop::Lint::FloatOutOfRange - does not register an offense for tiny little itty bitty floats - does not register an offense for 0.0 - does not register an offense for respectably sized floats - on floats so close to zero that nobody can tell the difference - registers an offense - on whopping big floats which tip the scales - registers an offense - -RuboCop::Cop::Lint::NonAtomicFileOperation - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` before creating file with an option `force: true` - does not register an offense when use `FileTest.exist?` before remove recursive file - does not register an offense when not checking for the existence - does not register an offense when using `FileTest.exist?` with `if` condition that has `else` branch - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exists?` before creating file - registers an offense when use file existence checks `unless` by postfix before creating file - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` with negated `if` before creating file - registers an offense when use file existence checks `if` by postfix before removing file - does not register an offense when not an exist check - registers an offense when use `FileTest.exist?` before force creating file - registers an offense when use `FileTest.exist?` before force creating file - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` before force remove file - does not register an offense when using complex conditional with `&&` - registers an offense when use `FileTest.exist?` before force remove file - registers an offense when use `FileTest.exist?` before creating file - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` before force creating file - registers an offense when use `FileTest.exist?` before remove file - registers an offense when using `FileTest.exist?` as a condition for `elsif` - does not register an offense when checking for the existence of different files - registers an offense when use `FileTest.exist?` before remove file - does not register an offense when processing other than file operations - does not register an offense when use `FileTest.exist?` before creating file with an option `force: false` - does not register an offense when not a method of file operation - registers an offense when use `FileTest.exist?` before remove file - registers an offense when use `FileTest.exist?` before creating file with an option not `force` - registers an offense when use `FileTest.exist?` before remove file - does not register an offense when use `FileTest.exist?` before remove recursive file - does not register an offense when using complex conditional with `||` - -RuboCop::Cop::Style::SingleLineBlockParams - finds incorrectly named parameters with leading underscores - reports an offense if the arguments names are wrong and not all arguments are given - allows calls with proper argument names - reports an offense if the names are in reverse order - does not report if the right names are used but not all arguments are given - reports an offense if the names are partially correct - does not report if no block arguments are present - ignores :reduce symbols - ignores do..end blocks - does not report when destructuring is used - allows an unused parameter to have a leading underscore - finds wrong argument names in calls with different syntax - -RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage - registers an offense when using `RUBY_VERSION` - does not register an offense when no `RUBY_VERSION` - registers an offense when using `::RUBY_VERSION` - -RuboCop::Cop::Style::NegatedUnless - does not blow up on a negated ternary operator - does not blow up for ternary ops - does not blow up for empty if condition - does not blow up for empty unless condition - with “both” style - registers an offense for unless with "not" condition - accepts an unless/else with negative condition - autocorrects by replacing parenthesized unless not with if - accepts an unless where the condition is doubly negated - registers an offense for unless with exclamation point condition - accepts an unless where only part of the condition is negated - with “prefix” style - registers an offense for prefix - does not register an offense for postfix - with “postfix” style - does not register an offense for prefix - registers an offense for postfix - -RuboCop::CLI - can process a file with an invalid UTF-8 byte sequence - registers an offense for a syntax error - does not register any offenses for an empty file - registers an offense for Parser warnings - finds a file with no .rb extension but has a shebang line - checks a given file with faults and returns 1 - configuration of target Ruby versions - when configured with an unsupported ruby - fails with an error message - when configured with an unknown version - fails with an error message - rubocop:disable comment - can disable selected cops in a code section - can disable selected cops on a single line - can disable all cops on a single line - can disable all cops in a code section - without using namespace - can disable selected cops on a single line but prints a warning - when not necessary - causes an offense to be reported - when using `rubocop:disable` line comment for `Lint/EmptyBlock` - does not register an offense for `Lint/RedundantCopDisableDirective` - and RedundantCopDisableDirective is disabled through department - does not report RedundantCopDisableDirective offenses - and RedundantCopDisableDirective is individually disabled - does not report RedundantCopDisableDirective offenses - and RedundantCopDisableDirective is individually excluded - does not report RedundantCopDisableDirective offenses - when using `rubocop:disable` line comment for `Style/RedundantInitialize` - does not register an offense for `Lint/RedundantCopDisableDirective` - and there are no other offenses - exits with error code - when --autocorrect-all is given - does not trigger RedundantCopDisableDirective due to lines moving around - Specify `--init` option to `rubocop` command - when .rubocop.yml already exists - fails with an error message - when .rubocop.yml does not exist - generate a .rubocop.yml file - configuration from file - prints an error message for an unrecognized EnforcedStyle - displays cop names if DisplayCopNames is false - prints an error for an unrecognized cop name in .rubocop.yml - works when a configuration file passed by -c specifies Exclude with strings - allows the default configuration file as the -c argument - prefers a config file in ancestor directory to another in home - can use an alternative max line length from a config file - can have different config files in different directories - can be configured to override a parameter that is a hash in a special case - matches included/excluded files correctly when . argument is given - can disable parser-derived offenses with warning severity - excludes the vendor directory by default - cannot disable Syntax offenses - does not read files in excluded list - can be configured with project config to disable a certain error - can exclude a vendor directory with an erroneous config file - only reads configuration in explicitly included hidden directories - works when a configuration file passed by -c specifies Exclude with regexp - works when a configuration file specifies Severity for Metrics/ParameterLists and Layout/LineLength - shows an error if the input file cannot be found - ignores excluded files - works when a configuration file specifies Severity for Metrics/ParameterLists and Layout - works when a cop that others depend on is disabled - can be configured with option to disable a certain error - displays style guide URLs if DisplayStyleGuide is true - can be configured to merge a parameter that is a hash - fails when a configuration file specifies an invalid Severity - prints a warning for an unrecognized configuration parameter - can exclude a vendor directory indirectly - can exclude directories relative to .rubocop.yml - can exclude a typical vendor directory - uses the DefaultFormatter if another formatter is not specified - fails when a configuration file has invalid YAML syntax - runs without errors for an unrecognized cop name in .rubocop.yml and `--ignore-unrecognized-cops` option is given - finds included files - does not consider Include parameters in subdirectories - when a value in a hash is overridden with nil - acts as if the key/value pair was removed - when a file inherits from a higher level - inherits relative excludes correctly - without using namespace - can be configured with option to disable a certain error - when MultilineOperationIndentation is used with aligned style and IndentationWidth parameter - fails with an error message - when configured for indented_internal_methods style indentation - accepts indented_internal_methods style indentation - registers offense for normal indentation in module - registers offense for normal indentation in class - when obsolete MultiSpaceAllowedForOperators param is used - displays a warning - when MultilineMethodCallIndentation is used with aligned style and IndentationWidth parameter - fails with an error message - when --force-default-config option is specified - when config file specified with -c - ignores config file - when no config file specified - ignores config file - when configuration is taken from $HOME/.rubocop.yml - handles relative excludes correctly when run from project root - info severity - when `Lint/Syntax` is given `Severity: info` - is an invalid configuration - when there are not only info offenses - returns a 1 code - when given `--display-only-fail-level-offenses` - returns a 0 code but does not list offenses - when given `--fail-level info` - returns a 1 code - when there are only info offenses - returns a 0 code - style guide only usage - via the cli option - --only-guide-cops - overrides configuration of AllCops/StyleGuideCopsOnly - skips cops that have no link to a style guide - runs cops for rules that link to a style guide - via the config - AllCops/DisabledByDefault - when it is false - runs all cops that are enabled in default configuration - when it is true - runs only the cop configured in .rubocop.yml - AllCops/StyleGuideCopsOnly - when it is true - skips cops that have no link to a style guide - when it is false - runs cops for rules regardless of any link to the style guide - cops can exclude files based on config - ignores excluded files - when a directory is named `*` - does not crash - when parallel static by default - when specifying `--debug` option only` - fails with an error message - when specifying `--debug` and `-a` options` - uses parallel inspection when correcting the file - when setting `UseCache: false` - fails with an error message - when setting `UseCache: true` - fails with an error message - unknown cop - in configuration file is given - prints the error and exists with code 2 - when interrupted - returns 130 - when errors are raised while processing files due to bugs - displays an error message to stderr - configuration of `require` - unknown library is specified - exits with 2 - when checking a correct file - returns 0 - when super is used with a block - still returns 0 - obsolete cops - when configuration for TrailingComma is given - fails with an error message - when lines end with CR+LF - reports an offense - configuration of `AutoCorrect` - when setting `AutoCorrect: false` for `Style/StringLiterals` - does not suggest `1 offense autocorrectable` for `Style/StringLiterals` - when given a file/directory that is not under the current dir - and the directory is absolute - checks a Rakefile but Style/FileName does not report - and the Rakefile path is absolute - checks a Rakefile but Style/FileName does not report - and the directory is relative - checks a Rakefile but Style/FileName does not report - and the Rakefile path is relative - checks a Rakefile but Style/FileName does not report - for a disabled cop - reports no offense when enabled on part of a file - -RuboCop::Cop::Style::IfUnlessModifier - accepts if/elsif - accepts if-end followed by a chained call using `.` - accepts if-else-end - accepts if-end when used as LHS of binary arithmetic - accepts if-end followed by a chained call using `&.` - adds parens in autocorrect when if-end used with `||` operator - accepts code with EOL comment since user might want to keep it - adds parens in autocorrect when if-end used with `&&` operator - behaves like condition modifier cop - for a multiline 'if' - accepts it if body spans more than one line - doesn't break when used as RHS of class var assignment - corrects it if result fits in one line - handles inline comments during autocorrection - accepts it when condition has local variable assignment - doesn't break when used as RHS of binary arithmetic - handles one-line usage - accepts it if single line would not fit on one line - accepts an empty body - corrects it when assignment is in body - doesn't break when used as RHS of constant assignment - doesn't break when used as RHS of local var assignment - doesn't break when used as RHS of instance var assignment - when Layout/LineLength is disabled - registers an offense even for a long modifier statement - when there is a comment on the first line and some code after the end keyword - does not register an offense - accepts multiline condition in modifier form - registers an offense - with a named regexp capture on the LHS - does not register an offense - behaves like condition modifier cop - for a multiline 'unless' - doesn't break when used as RHS of binary arithmetic - doesn't break when used as RHS of instance var assignment - doesn't break when used as RHS of class var assignment - handles inline comments during autocorrection - doesn't break when used as RHS of constant assignment - corrects it when assignment is in body - doesn't break when used as RHS of local var assignment - accepts it when condition has local variable assignment - accepts an empty body - accepts it if single line would not fit on one line - corrects it if result fits in one line - accepts it if body spans more than one line - handles one-line usage - accepts multiline condition in modifier form - registers an offense - when Layout/LineLength is disabled - registers an offense even for a long modifier statement - when there is a comment on the first line and some code after the end keyword - does not register an offense - modifier if that does not fit on one line - when Layout/LineLength is disabled with an EOL comment - accepts - when Layout/LineLength is disabled with enable/disable comments - accepts - when Layout/LineLength is enabled - corrects it to normal form - and the long line is allowed because AllowURI is true - accepts - IgnoreCopDirectives - and the long line is allowed because IgnoreCopDirectives is true - accepts - and the long line is too long because IgnoreCopDirectives is false - registers an offense - and the long line is too long because AllowURI is false - registers an offense - when variable assignment is used in the branch body of if modifier - registers an offense - when using a method with heredoc argument - accepts - when Layout/LineLength is disabled in configuration - accepts - multiline if that fits on one line with comment near end - accepts - modifier if that does not fit on one line, but is not the only statement on the line - accepts - when if-end condition is assigned to a variable - with variable being on the previous line - when it is short enough to fit on a single line - corrects it to the single-line form - when it is not short enough to fit on a single line - accepts it in the multiline form - with variable being on the same line - when it is not short enough to fit on a single line - accepts it in the multiline form - when it is short enough to fit on a single line - corrects it to the single-line form - when if-end condition is a value in a hash - when it is not short enough to fit on a single line - accepts it in the multiline form - when it is short enough to fit on a single line - corrects it to the single-line form - short multiline if near an else etc - registers an offense - when if-end condition has a first line comment - when it is not short enough to fit on a single line - accepts it in the multiline form - when it is short enough to fit on a single line - corrects it to the single-line form - if-end with conditional as body - accepts - if-end is argument to a parenthesized method call - adds parentheses because otherwise it would cause SyntaxError - with tabs used for indentation - with Layout/IndentationWidth: Width config - behaves like with tabs indentation - it fits on one line - registers an offense - it doesn't fit on one line - doesn't register an offense - with Layout/IndentationStyle: IndentationWidth config - behaves like with tabs indentation - it fits on one line - registers an offense - it doesn't fit on one line - doesn't register an offense - when if-end condition has some code after the end keyword - when it is not short enough to fit on a single line - accepts it in the multiline form - when it is short enough to fit on a single line - corrects it to the single-line form - when Layout/LineLength is disabled - registers an offense even for a long modifier statement - multiline if that fits on one line with comment on first line - registers an offense and preserves comment - if-end is argument to a non-parenthesized method call - adds parentheses so as not to change meaning - multiline if that fits on one line - registers an offense - and has two statements separated by semicolon - accepts - when if-end condition is an element of an array - when short enough to fit on a single line - corrects it to the single-line form - when not short enough to fit on a single line - accepts it in the multiline form - unless-end with conditional as body - accepts - multiline unless that fits on one line - registers an offense - with implicit match conditional - when a multiline if fits on one line - registers an offense - when a multiline if doesn't fit on one line - accepts - -RuboCop::Cop::Lint::HashCompareByIdentity - does not register an offense for hash methods without `object_id` as key - registers an offense when using hash methods with `object_id` on receiver as a key - registers an offense when using hash method with `object_id` as a key - -RuboCop::Cop::Security::CompoundHash - registers an offense when using XOR assignment operator in the implementation of the hash method - registers an offense when using XOR and bitshifts - registers an offense if .hash is called on any elements of a hashed array - registers an offense when using XOR operator in the implementation of a dynamic hash method - registers an offense when using bitshift and OR - registers an offense when using XOR operator in the implementation of the hash method - does not register an offense when delegating to Array#hash - registers an offense when using XOR operator in the implementation of the hash method, even without sub-calls to hash - registers an offense when using XOR operator in the implementation of the hash singleton method - registers an offense when using multiplication in the implementation of the hash method - registers an offense when using XOR involving super - registers an offense when delegating to Array#hash for a single value - registers an offense for complex usage - registers an offense when using multiplication assignment operator in the implementation of the hash method - registers an offense when using XOR between an array hash and a class - does not register an offense when delegating to a single object - registers an offense when using addition assignment operator in the implementation of the hash method - registers an offense when using addition in the implementation of the hash method - registers an offense when using XOR operator in the implementation of the hash method, even if intermediate variable is used - registers an offense when using XOR operator in the implementation of a dynamic hash singleton method - -RuboCop::Cop::Style::PercentQLiterals - when EnforcedStyle is lower_case_q - without interpolation - accepts double quotes - accepts %q - accepts single quotes - registers offense for %Q - with special characters - accepts %Q - accepts %q - with interpolation - accepts %Q - accepts single quotes - accepts double quotes - accepts %q - when EnforcedStyle is upper_case_q - with interpolation - accepts double quotes - accepts %q - accepts %Q - accepts single quotes - without interpolation - accepts single quotes - accepts %Q - registers offense for %q - accepts double quotes - with special characters - accepts %Q - accepts %q - -RuboCop::Cop::Style::ClassCheck - when enforced style is is_a? - registers an offense for kind_of? and corrects to is_a? - when enforced style is kind_of? - registers an offense for is_a? and corrects to kind_of? - -RuboCop::Cop::Layout::BeginEndAlignment - accepts matching puts 1; begin ... end - accepts matching begin ... end - registers an offense for mismatched begin end and autocorrects - when EnforcedStyleAlignWith is start_of_line - accepts matching puts 1; begin ... end - accepts matching var = begin ... end - registers an offense for mismatched begin end and autocorrects - registers an offense for mismatched var << begin end and autocorrects - -RuboCop::Cop::Lint::RescueType - accepts rescuing nothing - accepts rescuing a single exception - accepts rescue modifier - accepts rescuing nothing within a method definition - behaves like offenses - def rescue - rescuing from [] - registers an offense and autocorrects - def rescue ensure - rescuing from [] - registers an offense and autocorrects - begin rescue ensure - rescuing from [] - registers an offense and autocorrects - begin rescue - rescuing from [] - registers an offense and autocorrects - rescuing from [] after another exception - registers an offense and autocorrects - rescuing from [] before another exception - registers an offense and autocorrects - behaves like offenses - begin rescue ensure - rescuing from nil - registers an offense and autocorrects - def rescue ensure - rescuing from nil - registers an offense and autocorrects - begin rescue - rescuing from nil - registers an offense and autocorrects - rescuing from nil after another exception - registers an offense and autocorrects - rescuing from nil before another exception - registers an offense and autocorrects - def rescue - rescuing from nil - registers an offense and autocorrects - behaves like offenses - def rescue ensure - rescuing from :symbol - registers an offense and autocorrects - begin rescue ensure - rescuing from :symbol - registers an offense and autocorrects - def rescue - rescuing from :symbol - registers an offense and autocorrects - begin rescue - rescuing from :symbol - registers an offense and autocorrects - rescuing from :symbol after another exception - registers an offense and autocorrects - rescuing from :symbol before another exception - registers an offense and autocorrects - behaves like offenses - begin rescue - rescuing from 0.0 before another exception - registers an offense and autocorrects - rescuing from 0.0 after another exception - registers an offense and autocorrects - rescuing from 0.0 - registers an offense and autocorrects - begin rescue ensure - rescuing from 0.0 - registers an offense and autocorrects - def rescue ensure - rescuing from 0.0 - registers an offense and autocorrects - def rescue - rescuing from 0.0 - registers an offense and autocorrects - behaves like offenses - def rescue ensure - rescuing from 0 - registers an offense and autocorrects - begin rescue ensure - rescuing from 0 - registers an offense and autocorrects - begin rescue - rescuing from 0 before another exception - registers an offense and autocorrects - rescuing from 0 - registers an offense and autocorrects - rescuing from 0 after another exception - registers an offense and autocorrects - def rescue - rescuing from 0 - registers an offense and autocorrects - behaves like offenses - def rescue ensure - rescuing from 'string' - registers an offense and autocorrects - begin rescue ensure - rescuing from 'string' - registers an offense and autocorrects - begin rescue - rescuing from 'string' before another exception - registers an offense and autocorrects - rescuing from 'string' - registers an offense and autocorrects - rescuing from 'string' after another exception - registers an offense and autocorrects - def rescue - rescuing from 'string' - registers an offense and autocorrects - behaves like offenses - begin rescue - rescuing from "#{string}" - registers an offense and autocorrects - rescuing from "#{string}" before another exception - registers an offense and autocorrects - rescuing from "#{string}" after another exception - registers an offense and autocorrects - begin rescue ensure - rescuing from "#{string}" - registers an offense and autocorrects - def rescue ensure - rescuing from "#{string}" - registers an offense and autocorrects - def rescue - rescuing from "#{string}" - registers an offense and autocorrects - behaves like offenses - begin rescue ensure - rescuing from {} - registers an offense and autocorrects - begin rescue - rescuing from {} after another exception - registers an offense and autocorrects - rescuing from {} - registers an offense and autocorrects - rescuing from {} before another exception - registers an offense and autocorrects - def rescue ensure - rescuing from {} - registers an offense and autocorrects - def rescue - rescuing from {} - registers an offense and autocorrects + registers an offense for subsequent repeated case conditionals + registers multiple offenses for multiple repeated case conditionals + accepts similar but not equivalent && expressions RuboCop::Cop::Layout::SpaceAroundKeyword - behaves like accept after - accepts `::` after keyword in `super::ModuleName` - behaves like accept before - accepts `+` before keyword in `a+begin; end.method` - behaves like accept around - accepts `,` around keyword in `a 1,next,1` - behaves like missing before - registers an offense for missing space before keyword in `begin ""ensure end` - behaves like accept around - accepts `[]` around keyword in `a[begin end]` behaves like missing before - registers an offense for missing space before keyword in `""rescue a` - behaves like missing after - registers an offense for missing space after keyword in `case a; when b; else"" end` and autocorrects + registers an offense for missing space before keyword in `case a; when b; ""else end` behaves like accept after - accepts `#` after keyword in `next#comment` + accepts `(` after keyword in `return(1)` behaves like missing after - registers an offense for missing space after keyword in `case"" when 1; end` and autocorrects + registers an offense for missing space after keyword in `break""` and autocorrects behaves like missing after - registers an offense for missing space after keyword in `if a; else"" end` and autocorrects + registers an offense for missing space after keyword in `defined?1` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `begin+1 end` and autocorrects behaves like missing before - registers an offense for missing space before keyword in `for x in []do end` + registers an offense for missing space before keyword in `1and 2` + behaves like missing after + registers an offense for missing space after keyword in `begin ensure"" end` and autocorrects behaves like accept after - accepts `(` after keyword in `yield(1)` - behaves like accept before - accepts `+` before keyword in `a+begin end` - behaves like accept before - accepts `|` before keyword in `loop { |x|break }` - behaves like accept before - accepts `==` before keyword in `a==begin end` - behaves like missing before - registers an offense for missing space before keyword in `for x in [] do "x"end` - behaves like accept before - accepts `=` before keyword in `a=begin end` - behaves like missing before - registers an offense for missing space before keyword in `until 1do end` + accepts `+` after keyword in `+begin end` behaves like accept after accepts `(` after keyword in `super(1)` + behaves like missing after + registers an offense for missing space after keyword in `next""` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `a do|x| end` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `END{}` and autocorrects behaves like accept after - accepts `[` after keyword in `super[1]` + accepts `#` after keyword in `next#comment` behaves like accept before - accepts `*` before keyword in `a*begin end` - behaves like missing after - registers an offense for missing space after keyword in `return""` and autocorrects + accepts `+` before keyword in `a+begin; end.method` + behaves like accept before + accepts `+` before keyword in `a+begin end` behaves like accept after - accepts `(` after keyword in `break(1)` + accepts `(` after keyword in `not(1)` + behaves like missing after + registers an offense for missing space after keyword in `case a; when b; else"" end` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `if a then"" end` and autocorrects &. behaves like accept after accepts `&.` after keyword in `super&.foo` behaves like accept after accepts `&.` after keyword in `yield&.foo` + behaves like missing before + registers an offense for missing space before keyword in `if a; ""elsif b; end` + behaves like missing after + registers an offense for missing space after keyword in `while 1 do"x" end` and autocorrects behaves like accept after - accepts `(` after keyword in `return(1)` + accepts `[` after keyword in `yield[1]` behaves like missing after - registers an offense for missing space after keyword in `super""` and autocorrects + registers an offense for missing space after keyword in `case a when""; end` and autocorrects behaves like missing after - registers an offense for missing space after keyword in `END{}` and autocorrects + registers an offense for missing space after keyword in `1 and(2)` and autocorrects behaves like accept after - accepts `(` after keyword in `defined?(1)` - behaves like missing after - registers an offense for missing space after keyword in `begin"" end` and autocorrects + accepts `\n` after keyword in `test do +end` behaves like missing before registers an offense for missing space before keyword in `if a; ""else end` behaves like missing after - registers an offense for missing space after keyword in `while 1 do"x" end` and autocorrects + registers an offense for missing space after keyword in `begin rescue; else"" end` and autocorrects + behaves like accept after + accepts `\` after keyword in `test do\ +end` behaves like missing before - registers an offense for missing space before keyword in `if a; "b"end` - behaves like missing after - registers an offense for missing space after keyword in `1 and(2)` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `BEGIN{}` and autocorrects + registers an offense for missing space before keyword in `case ""when a; end` behaves like missing after - registers an offense for missing space after keyword in `super{}` and autocorrects + registers an offense for missing space after keyword in `not""` and autocorrects + behaves like accept around + accepts `[]` around keyword in `a[begin end]` behaves like accept before - accepts `!` before keyword in `!super.method` + accepts `**` before keyword in `a**begin end` + behaves like missing before + registers an offense for missing space before keyword in `1or 2` behaves like missing after - registers an offense for missing space after keyword in `a do|x| end` and autocorrects - behaves like accept before - accepts `/` before keyword in `a/begin end` - behaves like accept after - accepts `rescue` after keyword in `begin; rescue(Error); end` - behaves like accept after - accepts `[` after keyword in `yield[1]` + registers an offense for missing space after keyword in `case"" when 1; end` and autocorrects behaves like missing after registers an offense for missing space after keyword in `until 1 do"x" end` and autocorrects behaves like missing before - registers an offense for missing space before keyword in `begin "a"end` - behaves like accept before - accepts `>` before keyword in `a>begin end` + registers an offense for missing space before keyword in `begin rescue; ""else end` + behaves like missing before + registers an offense for missing space before keyword in `a do "a"end` + behaves like missing after + registers an offense for missing space after keyword in `yield""` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `for x in [] do"x" end` and autocorrects + behaves like missing before + registers an offense for missing space before keyword in `until 1do end` behaves like accept after - accepts `(` after keyword in `next(1)` + accepts `(` after keyword in `yield(1)` behaves like missing before - registers an offense for missing space before keyword in `1until ""` + registers an offense for missing space before keyword in `while 1 do "x"end` + behaves like accept before + accepts `-` before keyword in `a-begin end` + behaves like accept before + accepts `!` before keyword in `!super.method` + behaves like missing before + registers an offense for missing space before keyword in `for x in [] do "x"end` + behaves like accept before + accepts `||` before keyword in `a||begin end` behaves like missing after - registers an offense for missing space after keyword in `if""; end` and autocorrects + registers an offense for missing space after keyword in `return""` and autocorrects behaves like missing before registers an offense for missing space before keyword in `a "b"do end` behaves like accept before - accepts `!` before keyword in `!yield.method` - >= Ruby 2.7 - behaves like missing before - registers an offense for missing space before keyword in `""in a` - behaves like missing after - registers an offense for missing space after keyword in `case a; in""; end` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `a in""` and autocorrects + accepts `=` before keyword in `a=begin end` behaves like accept around accepts `{}` around keyword in `"#{begin end}"` behaves like missing before - registers an offense for missing space before keyword in `a do "a"end` + registers an offense for missing space before keyword in `1until ""` behaves like missing after - registers an offense for missing space after keyword in `if a; elsif""; end` and autocorrects + registers an offense for missing space after keyword in `if a; else"" end` and autocorrects behaves like missing after - registers an offense for missing space after keyword in `for x in [] do"x" end` and autocorrects - behaves like missing before - registers an offense for missing space before keyword in `if a; ""elsif b; end` - behaves like accept after - accepts `{` after keyword in `loop{}` - behaves like accept around - accepts `{}` around keyword in `loop {next}` + registers an offense for missing space after keyword in `unless""; end` and autocorrects behaves like accept before - accepts `-` before keyword in `a-begin end` - behaves like missing after - registers an offense for missing space after keyword in `defined?1` and autocorrects - behaves like accept around - accepts `()` around keyword in `(next)` + accepts `|` before keyword in `loop { |x|break }` + behaves like missing before + registers an offense for missing space before keyword in `if a; "b"end` behaves like accept around - accepts `[]` around keyword in `[begin end]` - >= Ruby 2.7 - behaves like missing after - registers an offense for missing space after keyword in `case""; in 1; end` and autocorrects + accepts `,` around keyword in `a 1,next,1` behaves like missing after - registers an offense for missing space after keyword in `begin+1 end` and autocorrects + registers an offense for missing space after keyword in `if a; elsif""; end` and autocorrects behaves like accept after - accepts `.` after keyword in `yield.method` - behaves like missing after - registers an offense for missing space after keyword in `next""` and autocorrects + accepts `(` after keyword in `break(1)` >= Ruby 3.0 behaves like accept after accepts `=>` after keyword in `a =>""` behaves like accept before accepts `=>` before keyword in `""=> a` behaves like missing after - registers an offense for missing space after keyword in `break""` and autocorrects + registers an offense for missing space after keyword in `1 while""` and autocorrects + behaves like accept around + accepts `[]` around keyword in `[begin end]` + behaves like missing after + registers an offense for missing space after keyword in `if""; end` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `super""` and autocorrects + behaves like accept after + accepts `[` after keyword in `super[1]` behaves like missing before - registers an offense for missing space before keyword in `1or 2` + registers an offense for missing space before keyword in `while 1do end` + behaves like accept around + accepts `{}` around keyword in `loop {next}` + behaves like accept before + accepts `&&` before keyword in `a&&begin end` behaves like missing before - registers an offense for missing space before keyword in `case a; when b; ""else end` + registers an offense for missing space before keyword in `begin "a"end` + behaves like missing before + registers an offense for missing space before keyword in `until 1 do "x"end` behaves like missing after - registers an offense for missing space after keyword in `begin ensure"" end` and autocorrects - behaves like accept after - accepts `\` after keyword in `test do\ -end` + registers an offense for missing space after keyword in `begin"" end` and autocorrects behaves like missing before - registers an offense for missing space before keyword in `1and 2` + registers an offense for missing space before keyword in `if ""then a end` + behaves like accept around + accepts `;` around keyword in `test do;end` + behaves like accept around + accepts `{}` around keyword in `{a: begin end}` + behaves like accept after + accepts `{` after keyword in `loop{}` + behaves like missing after + registers an offense for missing space after keyword in `super{}` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `1 or(2)` and autocorrects + behaves like accept after + accepts `(` after keyword in `defined?(1)` >= Ruby 2.7 behaves like missing after - registers an offense for missing space after keyword in `case a; in b; else"" end` and autocorrects + registers an offense for missing space after keyword in `a in""` and autocorrects behaves like missing before - registers an offense for missing space before keyword in `case a; in "pattern"unless "condition"; else "" end` - behaves like missing after - registers an offense for missing space after keyword in `case a; in "pattern" if"condition"; else "" end` and autocorrects + registers an offense for missing space before keyword in `""in a` behaves like missing after - registers an offense for missing space after keyword in `case a; in "pattern" unless"condition"; else "" end` and autocorrects - behaves like missing before - registers an offense for missing space before keyword in `case a; in "pattern"if "condition"; else "" end` - behaves like missing before - registers an offense for missing space before keyword in `case a; in b; ""else end` + registers an offense for missing space after keyword in `case a; in""; end` and autocorrects behaves like accept before - accepts `||` before keyword in `a||begin end` - behaves like accept around - accepts `{}` around keyword in `{a: begin end}` - behaves like accept after - accepts `\n` after keyword in `test do -end` + accepts `!` before keyword in `!yield.method` behaves like missing after - registers an offense for missing space after keyword in `a rescue""` and autocorrects - behaves like missing before - registers an offense for missing space before keyword in `until 1 do "x"end` + registers an offense for missing space after keyword in `BEGIN{}` and autocorrects behaves like accept before - accepts `<` before keyword in `a` before keyword in `a>begin end` behaves like missing before - registers an offense for missing space before keyword in `case ""when a; end` + registers an offense for missing space before keyword in `for x in []do end` + behaves like missing before + registers an offense for missing space before keyword in `1while ""` + behaves like accept after + accepts `rescue` after keyword in `begin; rescue(Error); end` + behaves like accept after + accepts `(` after keyword in `next(1)` behaves like accept before accepts `!` before keyword in `!yield` behaves like missing after - registers an offense for missing space after keyword in `unless""; end` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `begin rescue; else"" end` and autocorrects - behaves like missing before - registers an offense for missing space before keyword in `if ""then a end` - behaves like accept after - accepts `+` after keyword in `+begin end` - behaves like missing before - registers an offense for missing space before keyword in `while 1do end` + registers an offense for missing space after keyword in `a rescue""` and autocorrects behaves like missing before - registers an offense for missing space before keyword in `while 1 do "x"end` + registers an offense for missing space before keyword in `begin ""ensure end` behaves like accept before accepts `=*` before keyword in `a=*begin end` behaves like accept before - accepts `&&` before keyword in `a&&begin end` - behaves like missing after - registers an offense for missing space after keyword in `1 while""` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `case a when""; end` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `1 until""` and autocorrects + accepts `<` before keyword in `a= Ruby 2.7 + behaves like missing after + registers an offense for missing space after keyword in `case""; in 1; end` and autocorrects + behaves like accept before + accepts `==` before keyword in `a==begin end` behaves like accept after - accepts `(` after keyword in `not(1)` + accepts `::` after keyword in `super::ModuleName` behaves like accept before - accepts `**` before keyword in `a**begin end` - behaves like accept around - accepts `;` around keyword in `test do;end` + accepts `/` before keyword in `a/begin end` behaves like missing after - registers an offense for missing space after keyword in `if a then"" end` and autocorrects + registers an offense for missing space after keyword in `1 until""` and autocorrects behaves like accept after accepts `.` after keyword in `begin end.inspect` - behaves like missing after - registers an offense for missing space after keyword in `yield""` and autocorrects - behaves like missing before - registers an offense for missing space before keyword in `begin rescue; ""else end` - behaves like missing after - registers an offense for missing space after keyword in `1 or(2)` and autocorrects - behaves like missing after - registers an offense for missing space after keyword in `not""` and autocorrects + behaves like accept after + accepts `.` after keyword in `yield.method` behaves like missing before - registers an offense for missing space before keyword in `1while ""` + registers an offense for missing space before keyword in `""rescue a` + >= Ruby 2.7 + behaves like missing before + registers an offense for missing space before keyword in `case a; in "pattern"unless "condition"; else "" end` + behaves like missing after + registers an offense for missing space after keyword in `case a; in "pattern" if"condition"; else "" end` and autocorrects + behaves like missing before + registers an offense for missing space before keyword in `case a; in "pattern"if "condition"; else "" end` + behaves like missing after + registers an offense for missing space after keyword in `case a; in b; else"" end` and autocorrects + behaves like missing after + registers an offense for missing space after keyword in `case a; in "pattern" unless"condition"; else "" end` and autocorrects + behaves like missing before + registers an offense for missing space before keyword in `case a; in b; ""else end` + behaves like accept before + accepts `*` before keyword in `a*begin end` -RuboCop::Cop::Style::IfUnlessModifierOfIfUnless - provides a good error message - `unless` / `else` with modifier +RuboCop::Cop::Style::ClassMethods + does not register an offense outside class/module bodies + does not register an offense for methods using self + registers an offense for methods using a class name + does not register an offense for other top-level singleton methods + registers an offense for methods using a module name + +RuboCop::Formatter::TextUtil + pluralize + will pluralize -1 + will change 0 to no when configured + will not change 0 to no + will pluralize fractions + will not pluralize 1 + will pluralize quantities greater than 1 + will pluralize negative quantities less than -1 + +RuboCop::Cop::Layout::HashAlignment + accepts single line hash + register no offense for yield without args + accepts pairs that don't start a line + accepts several pairs per line + register no offense for superclass call without args + with `EnforcedColonStyle`: `table` + when using hash value omission + and aligned keys + does not register an offense and corrects + and a double splat argument after a hash key + registers an offense on the misaligned key and corrects + when the only item is a kwsplat + does not register an offense + and a misaligned double splat argument + registers an offense and corrects + and aligned keys but a double splat argument after + does not register an offense on the `kwsplat` + and misaligned keys + registers an offense and corrects + with separator alignment configuration + accepts hashes with different separators + registers an offense and corrects misaligned hash rockets + accepts an empty hash + accepts aligned hash keys + accepts single line hash + registers an offense and corrects misaligned hash values + doesn't break code by moving long keys too far left + accepts pairs that don't start a line + accepts several pairs per line + registers an offense and corrects mixed indentation and spacing + when using hash value omission + registers an offense and corrects mixed indentation and spacing + accepts aligned hash keys + when using hash value omission + accepts single line hash + accepts several pairs per line + accepts pairs that don't start a line + always ignore last argument hash + accepts misaligned keys in implicit hash + accepts misaligned keys in implicit hash for super + accepts misaligned keys in explicit hash + accepts misaligned keys in implicit hash for yield + accepts misaligned keys in explicit hash for super + accepts misaligned keys in explicit hash for yield + with `EnforcedHashRocketStyle`: `table` + when the only item is a kwsplat + does not register an offense + and a double splat argument after a hash key + registers an offense on the misaligned key and corrects + and aligned keys but a double splat argument after + does not register an offense on the `kwsplat` + and misaligned keys + registers an offense and corrects + and a misaligned double splat argument + registers an offense and corrects + with table alignment configuration + registers an offense and corrects misaligned hash rockets + accepts several pairs per line + registers an offense and corrects for misaligned hash keys + accepts a symbol only hash followed by a keyword splat + accepts aligned hash keys and values + accepts a keyword splat only hash + accepts pairs that don't start a line + accepts single line hash + registers an offense for misaligned hash values + accepts a multiline array of single line hashes + accepts hashes that use different separators + accepts hashes that use different separators and double splats + accepts an empty hash + when using hash value omission + accepts aligned hash keys and values + when using hash value omission + accepts several pairs per line + accepts pairs that don't start a line + accepts single line hash + ignore implicit last argument hash + registers an offense and corrects misaligned keys in explicit hash for super + accepts misaligned keys in implicit hash for super + accepts misaligned keys in implicit hash for yield + accepts misaligned keys in implicit hash + registers an offense and corrects misaligned keys in explicit hash for yield + registers an offense and corrects misaligned keys in explicit hash + always inspect last argument hash + registers an offense and corrects misaligned keys in implicit hash for super + registers an offense and corrects misaligned keys in implicit hash for yield + registers an offense and corrects misaligned keys in explicit hash for yield + registers an offense and corrects misaligned keys in explicit hash for super + registers offense and corrects misaligned keys in explicit hash + registers offense and corrects misaligned keys in implicit hash + when using hash value omission + registers offense and corrects misaligned keys in implicit hash + registers offense and corrects misaligned keys in explicit hash + when using hash value omission + accepts pairs that don't start a line + accepts single line hash + accepts several pairs per line + with table+separator alignment configuration + accepts a single method argument entry with colon + with multiple preferred(key and table) alignment configuration + registers an offense and corrects misaligned hash values, prefer key when least offenses + accepts an empty hash + accepts aligned hash keys with mixed hash style + registers an offense and corrects misaligned hash keys with mixed hash style + registers an offense and corrects misaligned hash values, prefer table when least offenses + registers an offense and corrects misaligned hash values + accepts aligned hash keys, by both + registers an offense and corrects misaligned hash values, works separate for each hash + accepts aligned hash keys, by keys + accepts aligned hash keys, by table + table and key config + registers an offense and corrects misaligned hash values, prefer table because it is specified first + ignore explicit last argument hash + registers an offense and corrects misaligned keys in implicit hash + accepts misaligned keys in explicit hash for super + accepts misaligned keys in explicit hash for yield + registers an offense and corrects misaligned keys in implicit hash for super + accepts misaligned keys in explicit hash + registers an offense and corrects misaligned keys in implicit hash for yield + when using hash value omission + registers an offense and corrects misaligned keys in implicit hash + accepts misaligned keys in explicit hash + with default configuration + registers an offense and corrects alignment when using double splat in an explicit hash + registers an offense and corrects separator alignment + registers an offense and corrects table alignment + registers an offense and corrects zero or multiple spaces + registers an offense and corrects misaligned hash keys + accepts left-aligned hash keys with single spaces + registers an offense and corrects misaligned mixed multiline hash keys + registers an offense and corrects multiline value starts in wrong place + registers an offense and corrects alignment when using double splat in braces + does not register an offense when value starts on next line + registers an offense and corrects mixed hash styles + with implicit hash as last argument + accepts aligned hash keys + registers an offense and corrects right alignment of keys + accepts an empty hash + registers an offense and corrects misaligned hash keys + with different settings for => and : + accepts aligned entries + registers offenses and correct misaligned entries + when `EnforcedStyle: with_fixed_indentation` of `ArgumentAlignment` + does not register an offense using aligned hash literal + register and corrects an offense + does not register an offense for an empty hash literal + registers and corrects an offense when using misaligned keyword arguments + does not register an offense using aligned hash argument for `proc.()` + when using hash value omission + does not register and corrects an offense when using aligned keyword arguments + register and corrects an offense + with invalid configuration + fails + +RuboCop::Cop::Style::EmptyLambdaParameter + accepts a keyword lambda + registers an offense for an empty block parameter with a lambda + does not crash on a super + +RuboCop::Cop::Style::SingleLineBlockParams + finds wrong argument names in calls with different syntax + reports an offense if the names are in reverse order + finds incorrectly named parameters with leading underscores + reports an offense if the names are partially correct + ignores :reduce symbols + reports an offense if the arguments names are wrong and not all arguments are given + does not report when destructuring is used + does not report if the right names are used but not all arguments are given + ignores do..end blocks + allows calls with proper argument names + does not report if no block arguments are present + allows an unused parameter to have a leading underscore + +RuboCop::Cop::Lint::OrAssignmentToConstant + does not register an offense with or-assignment to an attribute + does not register an offense with or-assignment to a local variable + registers an offense with or-assignment to a constant + does not register an offense with or-assignment to a class variable + does not register an offense with plain assignment to a constant + does not register an offense with or-assignment to an instance variable + does not register an offense with or-assignment to a global variable + +RuboCop::Cop::Style::IfWithSemicolon + accepts without `else` branch + can handle modifier conditionals + registers an offense and corrects for one line if/;/end + when elsif is present + accepts second elsif block + accepts with `else` branch + accepts without `else` branch + +RuboCop::Cop::Style::Not + autocorrects "not" with ! + uses the reverse operator when `not` is applied to a comparison + registers an offense for not + parenthesizes when `not` is applied to and + parenthesizes when `not` is applied to or + does not register an offense for ! + parenthesizes when `not` is applied to a ternary op + parenthesizes when `not` would change the meaning of a binary exp + autocorrects "not" followed by parens with ! + +RuboCop::Cop::Style::StringChars + does not register an offense when using `split` + does not register an offense when using `split(/ /)` + registers and corrects an offense when using `split("")` + registers and corrects an offense when using `split(//)` + does not register an offense when using `chars` + registers and corrects an offense when using `split('')` + registers and corrects an offense when using `split` without parentheses + +RuboCop::Cop::VariableForce::Assignment + #name + returns the variable name + #meta_assignment_node + when it is += operator assignment + returns op_asgn node + when it is &&= operator assignment + returns and_asgn node + when it is multiple assignment + returns masgn node + when it is ||= operator assignment + returns or_asgn node + .new + when an assignment node is passed + does not raise error + when an argument declaration node is passed + raises error + when any other type node is passed + raises error + #operator + when it is += operator assignment + returns += + when it is ||= operator assignment + returns ||= + when it is normal assignment + returns = + when it is multiple assignment + returns = + when it is &&= operator assignment + returns &&= + +RuboCop::Cop::Layout::EmptyLinesAroundBeginBody + accepts begin block without empty line + registers an offense for begin body starting in method + registers an offense for else body ending + accepts begin block without empty line in a method + registers an offense for begin body starting with a blank + registers an offense for begin body ending with a blank + registers an offense for ensure body ending + registers many offenses with complex begin-end + registers an offense for begin body ending in method + registers an offense for rescue body ending + registers an offense for begin body starting with rescue + +RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks + when many arguments are on multiple lines, two on same line registers an offense and corrects - nested conditionals - accepts - conditional with modifier in body - accepts - ternary with modifier + when argument starts on same line but ends on different line registers an offense and corrects - conditional with modifier + when many arguments are on multiple lines, three on same line + registers an offense and corrects + when bracket hash assignment key on multiple lines + does not add any offenses + when two arguments are on next line + does not add any offenses + when one argument on same line + does not add any offenses + when many arguments including hash are on multiple lines, three on same line + registers an offense and corrects + when second argument starts on same line as end of first + registers an offense and corrects + when there are multiple arguments on the first line + registers an offense and corrects starting from the 2nd argument + when bracket hash assignment on multiple lines + does not add any offenses + +RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis + incorrect cases + incorrect case in array with double heredoc and spaced out comma + detects + simple incorrect case comma with spaces and comma in heredoc + detects + simple incorrect case with call after trailing comma + detects + complex incorrect case with multiple calls + detects and fixes the first + detects and fixes the second + double case new line + detects and fixes + simple incorrect case + detects + incorrect case in array with spaced out comma + detects + complex chained incorrect case with multiple calls + detects and fixes the first + simple incorrect case comma + detects + incorrect case with other param after + detects + incorrect case in array with nested calls and double heredoc and spaced out comma + detects + simple incorrect case squiggles + detects + simple incorrect case with call after + detects + incorrect case with other param before constructor + detects + incorrect case with other param before + detects + incorrect case nested method call with comma + detects + double incorrect case + detects + simple incorrect case hash + detects + simple incorrect case comma with spaces + detects + nested incorrect case + detects + double incorrect case new line chained calls + detects + incorrect case with other param before constructor and raise call + detects + correct cases + accepts method with heredoc argument of proc correct case + accepts double correct case + accepts correct case with other param before + accepts simple correct case + accepts when there is an argument between a heredoc argument and the closing paretheses + accepts double correct case new line + accepts double correct case nested + accepts method chain with heredoc argument correct case + accepts correct case with other param after + accepts hash correct case + invocation after the HEREDOC + ignores random call after + ignores random call + ignores tr + +RuboCop::Cop::Style::TrailingCommaInArguments + with a single argument spanning multiple lines + when EnforcedStyleForMultiline is consistent_comma + accepts a single argument with no trailing comma + with multi-line list of values + when EnforcedStyleForMultiline is no_comma + accepts comma inside a heredoc parameter at the end + accepts comma inside a heredoc with method and comments inside + registers an offense for trailing comma in a method call with hash parameters at the end + accepts a method call with hash parameters at the end and no trailing comma + accepts comma inside a modified heredoc parameter + accepts comma inside a heredoc with comments inside + accepts comma inside a heredoc in brackets + autocorrects unwanted comma after modified heredoc parameter + when there is string interpolation inside heredoc parameter + accepts comma inside a heredoc parameter when on a single line + autocorrects unwanted comma inside string interpolation + accepts comma inside a heredoc parameter + when EnforcedStyleForMultiline is consistent_comma + accepts trailing comma in a method call with hash parameters at the end + registers an offense for no trailing comma in a method call withtwo parameters on the same line + accepts no trailing comma in a method call with a block parameter at the end + registers an offense for no trailing comma in a method call with hash parameters at the end + accepts a trailing comma in a method call with single line hashes + accepts a trailing comma in a method call with a single hash parameter + accepts a trailing comma in a method call with a single hash parameter to a receiver object + autocorrects missing comma after a heredoc + accepts a multiline call with arguments on a single line and trailing comma + accepts a multiline call with single argument on multiple lines + accepts a multiline call with a single argument and trailing comma + when closing bracket is on same line as last value + registers an offense for a method call, with a Hash as the last parameter, split on multiple lines + when EnforcedStyleForMultiline is comma + does not break when a safe method call is chained on the offending more complex one + accepts a trailing comma in a method call with single line hashes + accepts an empty hash being passed as a method argument + accepts missing comma after heredoc with comments + accepts no trailing comma in a method call with a multiline braceless hash at the end with more than one parameter on a line + does not break when a safe method call is chained on the offending simple one + accepts a method call with two parameters on the same line + accepts trailing comma in a method call with hash parameters at the end + accepts a multiline call with a single argument and trailing comma + does not break when a method call is chained on the offending one + registers an offense for no trailing comma in a method call with hash parameters at the end + when closing bracket is on same line as last value + accepts a method call with Hash as last parameter split on multiple lines + with a single argument of anonymous function spanning multiple lines + when EnforcedStyleForMultiline is consistent_comma + accepts a single argument with no trailing comma + with single line list of values + when EnforcedStyleForMultiline is comma + accepts chained single-line method calls + registers an offense for trailing comma preceded by whitespace in a method call + accepts method call without trailing comma when a line break before a method call + registers an offense for trailing comma in a method call + registers an offense for trailing comma in a method call with hash parameters at the end + accepts method call without trailing comma + accepts method call without parameters + accepts heredoc without trailing comma + accepts method call without trailing comma with single element hash parameters at the end + when using safe navigation operator + registers an offense for trailing comma in a method call + registers an offense for trailing comma in a method call with hash parameters at the end + when EnforcedStyleForMultiline is consistent_comma + accepts method call without trailing comma when a line break before a method call + registers an offense for trailing comma in a method call with hash parameters at the end + registers an offense for trailing comma in a method call + accepts method call without parameters + accepts method call without trailing comma with single element hash parameters at the end + registers an offense for trailing comma preceded by whitespace in a method call + accepts method call without trailing comma + accepts chained single-line method calls + accepts heredoc without trailing comma + when using safe navigation operator + registers an offense for trailing comma in a method call with hash parameters at the end + registers an offense for trailing comma in a method call + when EnforcedStyleForMultiline is no_comma + registers an offense for trailing comma in a method call with hash parameters at the end + registers an offense for trailing comma in a method call + registers an offense for trailing comma preceded by whitespace in a method call + accepts chained single-line method calls + accepts heredoc without trailing comma + accepts method call without parameters + accepts method call without trailing comma + accepts method call without trailing comma with single element hash parameters at the end + accepts method call without trailing comma when a line break before a method call + when using safe navigation operator + registers an offense for trailing comma in a method call + registers an offense for trailing comma in a method call with hash parameters at the end + +RuboCop::Cop::Style::RedundantParentheses + registers an offense for parens around an interpolated expression + accepts parentheses around operator keywords + registers an offense and corrects an array of multiple heredocs + accepts parentheses when enclosed in parentheses at `while-post` + accepts parentheses when they touch the preceding keyword + registers an offense for parens around a literal hash value + registers an offense for parens around a receiver of a method call with an argument + registers an offense for parens around a positive exponent + accepts parentheses when enclosed in parentheses at `until-post` + registers an offense for parens around a literal in array and following newline + registers an offense for parens around method body + accepts parentheses in super call with hash + registers an offense for parens around a literal in array + registers an offense for parens around a negative exponent + registers an offense for parens around last expressions in method body + accepts parentheses around a constant passed to when + registers an offense for parens around last expressions in block body + accepts parentheses when they touch the following keyword + accepts parentheses inside an irange + accepts parentheses around an irange + registers an offense for parens around a literal hash value and following newline + accepts parentheses around a method call with unparenthesized arguments + registers an offense and corrects for a parenthesized item in a hash where the comma is on a line with the closing parens + registers an offense for parens around an integer exponentiation base + registers an offense and corrects when method arguments are unnecessarily parenthesized + registers an offense for parens around a block body + registers an offense when there is space around the parentheses + registers an offense for parens around a variable after semicolon + accepts parentheses around the error passed to rescue + accepts parentheses around an erange + accepts parentheses in yield call with hash + registers an offense for parens around a float exponentiation base + accepts parentheses inside an erange + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a variable + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a variable + behaves like redundant + registers an offense for parentheses around a method call + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a method call + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around an unary operation + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around an unary operation + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + when parentheses are used like method argument parentheses + accepts parens around the arg + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a method call + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a method call + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around an unary operation + behaves like keyword with arguments + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a method call + behaves like redundant + registers an offense for parentheses around a variable + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a method call + behaves like redundant + registers an offense for parentheses around a method call + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a method call + behaves like redundant + registers an offense for parentheses around a literal + when a non-parenthesized call has an arg and a block + accepts parens around the arg + behaves like redundant + registers an offense for parentheses around a method call + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a constant + behaves like redundant + registers an offense for parentheses around an unary operation + behaves like redundant + registers an offense for parentheses around a literal + behaves like keyword with return value + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + ternaries + when Style/TernaryParentheses has EnforcedStyle: require_no_parentheses + registers an offense for parens around ternary condition + when Style/TernaryParentheses is not enabled + registers an offense for parens around constant ternary condition + when Style/TernaryParentheses has EnforcedStyle: require_parentheses + behaves like plausible + accepts parentheses when arguments are unparenthesized + when Style/TernaryParentheses has EnforcedStyle: require_parentheses_when_complex + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like keyword with return value + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + when the first argument in a method call begins with a hash literal + registers an offense if the argument list is parenthesized + accepts parentheses if the argument list is not parenthesized + behaves like keyword with arguments + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like keyword with return value + behaves like redundant + registers an offense for parentheses around a keyword + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a keyword + behaves like redundant + registers an offense for parentheses around a literal + behaves like plausible + accepts parentheses when arguments are unparenthesized + literals in an array + when there is a comma on the same line as the closing parentheses + registers an offense and corrects when there is a trailing comma + registers an offense and corrects when there is a subsequent item + registers an offense and corrects when there is assignment + registers an offense and corrects when there is no subsequent item + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a literal + behaves like plausible + accepts parentheses when arguments are unparenthesized + behaves like redundant + registers an offense for parentheses around a literal + behaves like redundant + registers an offense for parentheses around a keyword + when a hash literal is the second argument in a method call + registers an offense + behaves like redundant + registers an offense for parentheses around a literal + pin operator + behaves like allowed parentheses + accepts parentheses on a method call on an instance variable + behaves like allowed parentheses + accepts parentheses on a function call with arguments + behaves like redundant parentheses + registers an offense and corrects an instance variable + behaves like allowed parentheses + accepts parentheses on an array literal + behaves like redundant parentheses + registers an offense and corrects a class variable + behaves like allowed parentheses + accepts parentheses on a method call on a global variable + behaves like allowed parentheses + accepts parentheses on a method call on a local variable + behaves like allowed parentheses + accepts parentheses on a method call on a class variable + behaves like redundant parentheses + registers an offense and corrects a local variable + behaves like allowed parentheses + accepts parentheses on a range literal + behaves like redundant parentheses + registers an offense and corrects a global variable + behaves like allowed parentheses + accepts parentheses on an int literal + behaves like allowed parentheses + accepts parentheses on a hash literal + behaves like allowed parentheses + accepts parentheses on an expression + behaves like allowed parentheses + accepts parentheses on a function call with no arguments + +RuboCop::Cop::Style::RedundantRegexpCharacterClass + with a character class containing an escaped-# + registers an offense and corrects + with a character class containing a single character + registers an offense and corrects + with a negated character class with a single element + does not register an offense + with a character class containing a single unicode code-point + registers an offense and corrects + with a regexp containing invalid g escape + registers an offense and corrects + with a character class containing a space + with an unnecessary-character-class after a comment + registers an offense and corrects + when using free-spaced mode + with a commented single-element character class + does not register an offense + with a single space character class + does not register an offense with /iux + does not register an offense with /ix + does not register an offense with only /x + when not using free-spaced mode + registers an offense and corrects + with an array index inside an interpolation + does not register an offense + with a character class containing a negated-space meta-character + registers an offense and corrects + with a character class containing a single character before `+` quantifier + registers an offense and corrects + with consecutive escaped square brackets + does not register an offense + with a character class containing an escaped-b + does not register an offense + with consecutive escaped square brackets inside a character class + does not register an offense + with a character class containing a character requiring escape outside + does not register an offense + with a character class containing a negated posix bracket expression + does not register an offense + with a character class containing two characters + does not register an offense + with a character class containing an escaped [ + registers an offense and corrects + with a character class containing set intersection + does not register an offense + with %r{} regexp + with a character class containing a single character inside a group + registers an offense and corrects + with a character class containing a single character + registers an offense and corrects + with a character class containing a single character before `+` quantifier + registers an offense and corrects + with a character class containing a single character before `{n,m}` quantifier + registers an offense and corrects + with multiple character classes containing single characters + registers an offense and corrects + with an interpolated unnecessary-character-class regexp + registers an offense and corrects + with a character class containing a single negated unicode character property + registers an offense and corrects + with a character class containing an escaped ] + registers an offense and corrects + with a character class with first element an escaped ] + does not register an offense + with a character class containing a single range + does not register an offense + with a character class containing a single character inside a group + registers an offense and corrects + with a character class containing a single unicode character property + registers an offense and corrects + with multiple character classes containing single characters + registers an offense and corrects + with a character class containing a single character before `{n,m}` quantifier + registers an offense and corrects + with a redundant character class after an interpolation + registers an offense and corrects + with a character class containing a posix bracket expression + does not register an offense + with a character class containing an unescaped-# + registers an offense and corrects + with a character class containing multiple unicode code-points + does not register an offense and corrects + with a character class containing escaped character requiring escape outside + registers an offense and corrects + with a character class containing a space meta-character registers an offense and corrects + with a multi-line interpolation + ignores offenses in the interpolated expression + with escaped square brackets surrounding a single character + does not register an offense + with a character class containing an escaped-0 + does not register an offense + with a character class containing an interpolation + does not register an offense + +RuboCop::Cop::Style::Send + with __send__ + and without a receiver + does not register an offense for an invocation with args + does not register an offense for an invocation without args + and with a receiver + does not register an offense for an invocation with args + does not register an offense for an invocation without args + with public_send + and with a receiver + does not register an offense for an invocation with args + does not register an offense for an invocation without args + and without a receiver + does not register an offense for an invocation without args + does not register an offense for an invocation with args + with send + and without a receiver + registers an offense for an invocation with args + does not register an offense for an invocation without args + and with a receiver + registers an offense for an invocation with args + does not register an offense for an invocation without args + when using safe navigation operator + registers an offense for an invocation with args + +RuboCop::Cop::Layout::MultilineMethodCallBraceLayout + ignores calls with an empty brace + ignores implicit calls + ignores single-line calls + ignores calls without arguments + ignores calls with a multiline empty brace + when EnforcedStyle is new_line + ignores single-line calls with multi-line receiver with leading dot + still ignores single-line calls + ignores single-line calls with multi-line receiver + when comment present before closing brace + corrects closing brace without crashing + behaves like multiline literal brace layout + symmetrical style + opening brace on separate line from first element + allows closing brace on separate line from last element + detects closing brace on same line as last element + allows closing brace on separate line from last multiline element + opening brace on same line as first element + allows closing brace on same line as last element + detects closing brace on different line from last element + allows closing brace on same line as last multiline element + autocorrects closing brace on different line from last element + with a chained call on the closing brace + and a comment after the last element + detects closing brace on separate line from last elementbut does not autocorrect the closing brace + but no comment after the last element + autocorrects the closing brace + heredoc + ignores heredocs that could share a last line + detects heredoc structures that are safe to add to + new_line style + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last multiline element + allows closing brace on separate line from last element + opening brace on same line as first element + detects closing brace on same line as last multiline element + allows closing brace on different line from last element + allows closing brace on different line from multi-line element + autocorrects closing brace on same line as last element + same_line style + opening brace on separate line from first element + allows closing brace on same line as last multiline element + allows closing brace on same line as last element + detects closing brace on different line from last element + opening brace on same line as first element + allows closing brace on same line as multi-line element + detects closing brace on different line from multiline element + autocorrects closing brace on different line as last element + allows closing brace on same line from last element + with a chained call on the closing brace + but no comment after the last element + autocorrects the closing brace + and a comment after the last element + detects closing brace on separate line from last elementbut does not autocorrect the closing brace + behaves like multiline literal brace layout trailing comma + symmetrical style + opening brace on same line as first element + last element has a trailing comma + autocorrects closing brace on different line from last element + same_line style + opening brace on same line as first element + last element has a trailing comma + autocorrects closing brace on different line as last element + +RuboCop::Cop::Layout::LeadingCommentSpace + does not register an offense for only #s + accepts =begin/=end comments + does not register an offense for more than one # + accepts sprockets directives + registers an offense and corrects comment without leading space + does not register an offense for #! on first line + does not register an offense for more than one space + does not register an offense for # followed by no text + registers an offense and corrects #! after the first line + file named config.ru + registers an offense and corrects for #\ after the first line + does not register an offense for #\ on first line + Gemfile Ruby comment + when config option is enabled + file named Gemfile + does not register an offense when using ruby config as comment + file not named Gemfile + registers an offense when using ruby config as comment + when config option is disabled + registers an offense when using ruby config as comment + Doxygen style + when config option is enabled + does not register offense when using Doxygen style + when config option is disabled + registers an offense and corrects using Doxygen style + file not named config.ru + registers an offense and corrects #\ on first line + registers an offense and corrects #\ after the first line + RDoc syntax + registers an offense when starting `:` + does not register an offense when using `#++` or `#--` + +RuboCop::Cop::Style::NilLambda + Proc.new + does not register an offense when not returning nil + registers an offense when returning nil with `next` + registers an offense when returning nil with `break` + registers an offense when returning nil implicitly + does not register an offense when doing more than returning nil + registers an offense when returning nil with `return` + properly corrects single line + does not remove block params or change spacing + proc + registers an offense when returning nil implicitly + registers an offense when returning nil with `break` + registers an offense when returning nil with `next` + properly corrects single line + does not remove block params or change spacing + does not register an offense when not returning nil + registers an offense when returning nil with `return` + does not register an offense when doing more than returning nil + block lambda + properly corrects single line + does not remove block params or change spacing + registers an offense when returning nil with `next` + does not register an offense when not returning nil + does not register an offense when doing more than returning nil + registers an offense when returning nil with `return` + registers an offense when returning nil with `break` + registers an offense when returning nil implicitly + stabby lambda + registers an offense when returning nil implicitly + registers an offense when returning nil with `next` + does not register an offense when not returning nil + does not register an offense when doing more than returning nil + registers an offense when returning nil with `break` + registers an offense when returning nil with `return` + properly corrects multiline + +RuboCop::Cop::Style::EachWithObject + correctly autocorrects + ignores inject/reduce with assignment to accumulator param in block + ignores inject and reduce with condition as body + correctly autocorrects with return value only + ignores inject and reduce passed in symbol + ignores inject and reduce with passed in, but not returned hash + finds inject and reduce with passed in and returned hash + does not blow up for reduce with no arguments + ignores inject and reduce with empty body + when a simple literal is passed as initial value + ignores inject/reduce + Ruby 2.7 + finds inject and reduce with passed in and returned hash and numblock + +RuboCop::Cop::Style::AsciiComments + registers an offense for a comment with non-ascii chars + registers an offense for comments with mixed chars + accepts comments with only ascii chars + when certain non-ascii chars are allowed + registers an offense for comments with non-allowed non-ascii chars + accepts comment with allowed non-ascii chars + +RuboCop::Cop::Layout::SpaceAfterComma + method call arg commas without space + behaves like ends with an item + registers an offense and does autocorrection + inside hash braces + when EnforcedStyle for SpaceInsideBlockBraces is no_space + accepts no space between a comma and a closing brace + behaves like common behavior + accepts a space between a comma and a closing brace + when EnforcedStyle for SpaceInsideBlockBraces is space + registers an offense for no space between a comma and a closing brace + behaves like common behavior + accepts a space between a comma and a closing brace + block argument commas without space + behaves like ends with an item + registers an offense and does autocorrection + behaves like trailing comma + accepts the last comma + array index commas without space + behaves like trailing comma + accepts the last comma + behaves like ends with an item + registers an offense and does autocorrection + +RuboCop::Cop::Layout::FirstArrayElementLineBreak + ignores properly formatted implicit arrays + ignores elements listed on a single line + word arrays + registers and corrects the offense + masgn implicit arrays + registers and corrects the offense + array nested in a method call + registers an corrects the offense + send implicit arrays + registers and corrects the offense + elements listed on the first line + registers and corrects the offense + +RuboCop::Cop::Style::EndlessMethod + Ruby >= 3.0 + EnforcedStyle: disallow + registers an offense for an endless method with arguments + registers an offense for an endless method + EnforcedStyle: allow_single_line + registers an offense and corrects for a multiline endless method + does not register an offense for an endless method + does not register an offense for an endless method with arguments + registers an offense and corrects for a multiline endless method with arguments + registers an offense and corrects for a multiline endless method with begin + EnforcedStyle: allow_always + does not register an offense for a multiline endless method + does not register an offense for an endless method + does not register an offense for an endless method with arguments + does not register an offense for a multiline endless method with begin + does not register an offense for a multiline endless method with arguments + +RuboCop::Cop::Style::EnvHome + does not register an offense when using `Dir.home` + does not register an offense when using `ENV['HOME'] = '/home/foo'` + registers and corrects an offense when using `ENV.fetch('HOME', nil)` + registers and corrects an offense when using `ENV['HOME']` + does not register an offense when using `ENV.fetch('HOME', default)` + registers and corrects an offense when using `ENV.fetch('HOME')` + registers and corrects an offense when using `::ENV['HOME']` + +RuboCop::Cop::Lint::RequireRelativeSelfPath + does not register an offense when using a variable as an argument of `require_relative` + registers an offense when using `require_relative` with self file path argument + does not register an offense when using `require_relative` without self file path argument + registers an offense when using `require_relative` with self file path argument (with ext) + does not register an offense when the filename is the same but the extension does not match + does not register an offense when using `require_relative` without argument + +RuboCop::Cop::MessageAnnotator + #annotate + when the output format is JSON + returns the message unannotated + with default options + returns the message + with options on + returns an annotated message + #urls + returns an empty array without StyleGuide URL + returns style guide url when it is specified + returns multiple reference urls + returns reference url when it is specified + returns an empty array if the reference url is blank + returns style guide and reference url when they are specified + with style guide url + when StyleGuide is not set in the config + does not add style guide url + when StyleGuide is set in the config + adds style guide url + when a base URL is specified + can use a path-based setting + can accept relative paths if base has a full path + does not specify a URL if a cop does not have one + allows absolute URLs in the cop config + combines correctly with a target-based setting + when a department other than AllCops is specified + returns style guide url when it is specified + when a nested department is specified + returns style guide url when it is specified + +RuboCop::Cop::Layout::IndentationConsistency + with def/defs + registers an offense and corrects bad indentation in a def body + registers an offense and corrects bad indentation in a defs body + accepts an empty def body + accepts an empty defs body + with case + accepts case/when/else with then beginning a line + accepts indented when/else plus indented body + registers an offense and corrects bad indentation in a case/else body + accepts correctly indented case/when/else + registers an offense and corrects bad indentation in a case/when body + accepts case/when/else laid out as a table + with for + registers an offense and corrects bad indentation in a for body + accepts an empty for + with module + registers an offense and corrects bad indentation in a module body + accepts an empty module body + registers an offense and corrects bad indentation of private methods + even when there are no public methods + registers an offense and corrects bad indentation of private methods + with class + with normal style configured + registers an offense and corrects bad indentation in def but not for outdented public, protected, and private + accepts indented public, protected, and private + registers an offense and corrects bad indentation in a class body + accepts an empty class body + with indented_internal_methods style configured + accepts different indentation in different visibility sections when using `Struct.new` + accepts different indentation in different visibility sections + with unless + accepts an empty unless + registers an offense and corrects bad indentation in an unless body + with block + accepts a correctly indented block body + registers an offense and corrects bad indentation in a {} body + registers an offense and correct bad indentation in a do/end body + does not autocorrect an offense within another offense + accepts an empty block body + with top-level code + accepts when using access modifier at the top level + accepts an empty expression string interpolation + registers and corrects an offense when using access modifier and indented method definition at the top level + with while/until + registers an offense and corrects bad indentation in an until body + registers an offense and corrects bad indentation in a while body + accepts an empty while + registers an offense and corrects bad indentation in begin/end/while + with if statement + accepts an if in assignment with end aligned with variable + accepts if/then/else/end laid out as another table + accepts a one line if statement + accepts an if/else in assignment on next line with end aligned with if + accepts an if in assignment with end aligned with if + registers an offense and corrects bad indentation in an if body + accepts an if/else in assignment with end aligned with variable + accepts a correctly aligned if/elsif/else/end + accepts an if/else in assignment with end aligned with variable and chaining with a block after the end + accepts an if/else in assignment with end aligned with variable and chaining after the end + accepts an if/else branches with rescue clauses + accepts an empty if + accepts if/elsif/else/end laid out as a table + registers an offense and corrects bad indentation in an else body + accepts an if/else in assignment with end aligned with if + accepts if/elsif/else/end with fullwidth characters + registers an offense and corrects bad indentation in an elsif body + +RuboCop::Cop::Layout::MultilineHashBraceLayout + ignores single-line hashes + ignores implicit hashes + ignores empty hashes + behaves like multiline literal brace layout method argument + when arguments to a method + and a comment after the last element + detects closing brace on separate line from last element + but no comment after the last element + autocorrects the closing brace + behaves like multiline literal brace layout + same_line style + opening brace on separate line from first element + allows closing brace on same line as last element + detects closing brace on different line from last element + allows closing brace on same line as last multiline element + opening brace on same line as first element + allows closing brace on same line as multi-line element + autocorrects closing brace on different line as last element + detects closing brace on different line from multiline element + allows closing brace on same line from last element + with a chained call on the closing brace + but no comment after the last element + autocorrects the closing brace + and a comment after the last element + detects closing brace on separate line from last elementbut does not autocorrect the closing brace + heredoc + detects heredoc structures that are safe to add to + ignores heredocs that could share a last line + new_line style + opening brace on same line as first element + autocorrects closing brace on same line as last element + allows closing brace on different line from last element + detects closing brace on same line as last multiline element + allows closing brace on different line from multi-line element + opening brace on separate line from first element + allows closing brace on separate line from last element + allows closing brace on separate line from last multiline element + detects closing brace on same line as last element + symmetrical style + opening brace on same line as first element + allows closing brace on same line as last multiline element + detects closing brace on different line from last element + allows closing brace on same line as last element + autocorrects closing brace on different line from last element + with a chained call on the closing brace + but no comment after the last element + autocorrects the closing brace + and a comment after the last element + detects closing brace on separate line from last elementbut does not autocorrect the closing brace + opening brace on separate line from first element + detects closing brace on same line as last element + allows closing brace on separate line from last element + allows closing brace on separate line from last multiline element + behaves like multiline literal brace layout trailing comma + same_line style + opening brace on same line as first element + last element has a trailing comma + autocorrects closing brace on different line as last element + symmetrical style + opening brace on same line as first element + last element has a trailing comma + autocorrects closing brace on different line from last element Pending: (Failures listed here are expected and do not affect your suite's status) @@ -30177,10 +30213,10 @@ # /build/reproducible-path/rubocop-1.39.0+dfsg/spec/rubocop/cop/lint/useless_assignment_spec.rb:341:in `block (3 levels) in ' # /usr/share/rubygems-integration/all/gems/webmock-3.18.1/lib/webmock/rspec.rb:37:in `block (2 levels) in ' -Finished in 1 minute 55.13 seconds (files took 4.85 seconds to load) +Finished in 1 minute 37 seconds (files took 4.27 seconds to load) 19138 examples, 0 failures, 3 pending -Randomized with seed 11464 +Randomized with seed 12564 ┌──────────────────────────────────────────────────────────────────────────────┐ @@ -30213,12 +30249,14 @@ dpkg-buildpackage: info: binary-only upload (no source included) dpkg-genchanges: info: including full source code in upload I: copying local configuration +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/1998930/tmp/hooks/B01_cleanup finished I: unmounting dev/ptmx filesystem I: unmounting dev/pts filesystem I: unmounting dev/shm filesystem I: unmounting proc filesystem I: unmounting sys filesystem I: cleaning the build env -I: removing directory /srv/workspace/pbuilder/2981196 and its subdirectories -I: Current time: Tue Jun 17 15:04:15 -12 2025 -I: pbuilder-time-stamp: 1750215855 +I: removing directory /srv/workspace/pbuilder/1998930 and its subdirectories +I: Current time: Thu May 16 10:45:39 +14 2024 +I: pbuilder-time-stamp: 1715805939