Diff of the two buildlogs: -- --- b1/build.log 2024-05-21 07:53:34.267122498 +0000 +++ b2/build.log 2024-05-21 07:56:01.628853711 +0000 @@ -1,6 +1,6 @@ I: pbuilder: network access will be disabled during build -I: Current time: Mon May 20 19:52:46 -12 2024 -I: pbuilder-time-stamp: 1716277966 +I: Current time: Tue Jun 24 04:16:35 +14 2025 +I: pbuilder-time-stamp: 1750688195 I: Building the build Environment I: extracting base tarball [/var/cache/pbuilder/trixie-reproducible-base.tgz] I: copying local configuration @@ -29,52 +29,84 @@ dpkg-source: info: applying 0002-Fix-compile-task.patch I: Not using root during the build. I: Installing the build-deps -I: user script /srv/workspace/pbuilder/2262698/tmp/hooks/D02_print_environment starting +I: user script /srv/workspace/pbuilder/1444777/tmp/hooks/D01_modify_environment starting +debug: Running on codethink03-arm64. +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 Jun 23 14:16 /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/1444777/tmp/hooks/D01_modify_environment finished +I: user script /srv/workspace/pbuilder/1444777/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='arm64' - 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]="aarch64-unknown-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=arm64 + DEBIAN_FRONTEND=noninteractive DEB_BUILD_OPTIONS='buildinfo=+all reproducible=+all parallel=12 ' - DISTRIBUTION='trixie' - HOME='/root' - HOST_ARCH='arm64' + DIRSTACK=() + DISTRIBUTION=trixie + EUID=0 + FUNCNAME=([0]="Echo" [1]="main") + GROUPS=() + HOME=/root + HOSTNAME=i-capture-the-hostname + HOSTTYPE=aarch64 + HOST_ARCH=arm64 IFS=' ' - INVOCATION_ID='466f4cd3108b4a5dbd1e7b90a3f7a864' - 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='2262698' - PS1='# ' - PS2='> ' + INVOCATION_ID=35c305b7cd55406fa9e5507978e4f03f + LANG=C + LANGUAGE=nl_BE:nl + LC_ALL=C + MACHTYPE=aarch64-unknown-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=1444777 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.mgOubopK/pbuilderrc_DJod --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.mgOubopK/b1 --logfile b1/build.log ruby-rubocop-ast_1.24.0-2.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' - http_proxy='http://192.168.101.4:3128' + 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.mgOubopK/pbuilderrc_IJa2 --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.mgOubopK/b2 --logfile b2/build.log ruby-rubocop-ast_1.24.0-2.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' + http_proxy=http://192.168.101.4:3128 I: uname -a - Linux codethink04-arm64 6.1.0-21-cloud-arm64 #1 SMP Debian 6.1.90-1 (2024-05-03) aarch64 GNU/Linux + Linux i-capture-the-hostname 6.1.0-21-cloud-arm64 #1 SMP Debian 6.1.90-1 (2024-05-03) aarch64 GNU/Linux I: ls -l /bin - lrwxrwxrwx 1 root root 7 May 20 11:23 /bin -> usr/bin -I: user script /srv/workspace/pbuilder/2262698/tmp/hooks/D02_print_environment finished + lrwxrwxrwx 1 root root 7 Jun 21 17:48 /bin -> usr/bin +I: user script /srv/workspace/pbuilder/1444777/tmp/hooks/D02_print_environment finished -> Attempting to satisfy build-dependencies -> Creating pbuilder-satisfydepends-dummy package Package: pbuilder-satisfydepends-dummy @@ -262,7 +294,7 @@ Get: 138 http://deb.debian.org/debian trixie/main arm64 ruby-rspec-mocks all 3.13.0c0e0m0s1-2 [81.3 kB] Get: 139 http://deb.debian.org/debian trixie/main arm64 ruby-rspec all 3.13.0c0e0m0s1-2 [5184 B] Get: 140 http://deb.debian.org/debian trixie/main arm64 ruby-whitequark-parser all 3.1.3.0-1 [424 kB] -Fetched 46.8 MB in 0s (123 MB/s) +Fetched 46.8 MB in 1s (77.5 MB/s) debconf: delaying package configuration, since apt-utils is not installed Selecting previously unselected package libpython3.11-minimal:arm64. (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 ... 19746 files and directories currently installed.) @@ -728,8 +760,8 @@ Setting up tzdata (2024a-4) ... Current default time zone: 'Etc/UTC' -Local time is now: Tue May 21 07:53:09 UTC 2024. -Universal Time is now: Tue May 21 07:53:09 UTC 2024. +Local time is now: Mon Jun 23 14:17:34 UTC 2025. +Universal Time is now: Mon Jun 23 14:17:34 UTC 2025. Run 'dpkg-reconfigure tzdata' if you wish to change it. Setting up autotools-dev (20220109.1) ... @@ -856,7 +888,11 @@ Building tag database... -> Finished parsing the build-deps I: Building the package -I: Running cd /build/reproducible-path/ruby-rubocop-ast-1.24.0/ && 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 > ../ruby-rubocop-ast_1.24.0-2_source.changes +I: user script /srv/workspace/pbuilder/1444777/tmp/hooks/A99_set_merged_usr starting +Not re-configuring usrmerge for trixie +I: user script /srv/workspace/pbuilder/1444777/tmp/hooks/A99_set_merged_usr finished +hostname: Name or service not known +I: Running cd /build/reproducible-path/ruby-rubocop-ast-1.24.0/ && 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 > ../ruby-rubocop-ast_1.24.0-2_source.changes dpkg-buildpackage: info: source package ruby-rubocop-ast dpkg-buildpackage: info: source version 1.24.0-2 dpkg-buildpackage: info: source distribution unstable @@ -891,7 +927,7 @@ dh_prep -O--buildsystem=ruby dh_auto_install --destdir=debian/ruby-rubocop-ast/ -O--buildsystem=ruby dh_ruby --install /build/reproducible-path/ruby-rubocop-ast-1.24.0/debian/ruby-rubocop-ast -/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20240520-2268405-hwtyuc/gemspec +/usr/bin/ruby3.1 -S gem build --config-file /dev/null --verbose /tmp/d20250624-1481183-8k3zae/gemspec Failed to load /dev/null because it doesn't contain valid YAML hash WARNING: open-ended dependency on parser (>= 3.1.1.0) is not recommended if parser is semantically versioned, use: @@ -901,7 +937,7 @@ Name: rubocop-ast Version: 1.24.0 File: rubocop-ast-1.24.0.gem -/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/ruby-rubocop-ast/usr/share/rubygems-integration/all /tmp/d20240520-2268405-hwtyuc/rubocop-ast-1.24.0.gem +/usr/bin/ruby3.1 -S gem install --config-file /dev/null --verbose --local --verbose --no-document --ignore-dependencies --install-dir debian/ruby-rubocop-ast/usr/share/rubygems-integration/all /tmp/d20250624-1481183-8k3zae/rubocop-ast-1.24.0.gem Failed to load /dev/null because it doesn't contain valid YAML hash /build/reproducible-path/ruby-rubocop-ast-1.24.0/debian/ruby-rubocop-ast/usr/share/rubygems-integration/all/gems/rubocop-ast-1.24.0/lib/rubocop-ast.rb /build/reproducible-path/ruby-rubocop-ast-1.24.0/debian/ruby-rubocop-ast/usr/share/rubygems-integration/all/gems/rubocop-ast-1.24.0/lib/rubocop/ast.rb @@ -1028,105 +1064,1355 @@ warning: parser/current is loading parser/ruby31, which recognizes3.1.3-compliant syntax, but you are running 3.1.2. Please see https://github.com/whitequark/parser#compatibility-with-ruby-mri. -Randomized with seed 46892 +Randomized with seed 53969 -RuboCop::AST::EnsureNode +RuboCop::AST::DstrNode + #value + with implicit concatenation + is expected to eq "foo bar baz" + with interpolation + is expected to eq "foo \#{bar} baz" + with a multiline string + is expected to eq "this is a multiline string" + +RuboCop::AST::SymbolNode .new - is expected to be a kind of RuboCop::AST::EnsureNode - #body - is expected to be sym type + with a symbol node + is expected to be a kind of RuboCop::AST::SymbolNode + #value + is expected to eq :foo -Changelog - parses correctly - merges correctly - Changelog::Entry - generates correct content +RuboCop::AST::CaseMatchNode + when using Ruby 2.7 or newer + #else_branch + #else? + without an else statement + is expected to be nil + with an empty else statement + is expected to be empty else type + with an else statement + is expected to be sym type + #branches + when there is no else keyword + returns only then when bodies + when there is an else + with else body + returns all the bodies + with empty else + returns all the bodies + #else? + without an else statement + is expected not to be else + with an else statement + is expected to be else + #keyword + is expected to eq "case" + .new + is expected to be a kind of RuboCop::AST::CaseMatchNode + #in_pattern_branches + is expected to all be in pattern type + is expected to eq 3 + #each_in_pattern + when passed a block + yields all the conditions + when not passed a block + is expected to be a kind of Enumerator -RuboCop::AST::IntNode - #value - is expected to eq 10 - #sign? - explicit negative int - is expected to be sign - explicit positive int - is expected to be sign +RuboCop::AST::CasgnNode .new - is expected to be a kind of RuboCop::AST::IntNode + with a `casgn` node + is expected to be a kind of RuboCop::AST::CasgnNode + #expression + is expected to eq s(:send, nil, :value) + #namespace + when the parent is a `cbase` + is expected to eq s(:cbase) + when the parent is a `const` + is expected to eq s(:const, nil, :FOO) + when there is no parent + is expected to be nil + #name + is expected to eq :VAR + +RuboCop::AST::NodePattern + repeated + using ? + with too many matching children + behaves like nonmatching + doesn't match + behaves like repeated pattern + with an ellipsis in the same sequence + is expected to match code "[:hello, 1, 2, 3]" + at beginning of sequence + behaves like invalid + is invalid + with one match + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with zero match + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + using * + with matching children + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + without capture + is expected to match code s(:sym, :hello), s(:int, 1), s(:int, 2), and s(:int, 3) + with multiple subcaptures + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with zero match + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with no match + behaves like nonmatching + doesn't match + behaves like repeated pattern + at beginning of sequence + behaves like invalid + is invalid + with an ellipsis in the same sequence + is expected to match code "[:hello, 1, 2, 3]" + with one match + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + nested with multiple subcaptures + behaves like multiple capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + using + + with matching children + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + behaves like repeated pattern + with one match + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with an ellipsis in the same sequence + is expected to match code "[:hello, 1, 2, 3]" + at beginning of sequence + behaves like invalid + is invalid + with zero match + behaves like nonmatching + doesn't match + commas + with commas randomly strewn around + behaves like invalid + is invalid + sequence with trailing ... + on a node with fewer children, with a wildcard preceding + behaves like nonmatching + doesn't match + on a node with a different type + behaves like nonmatching + doesn't match + on a node with the same type and fewer children + behaves like nonmatching + doesn't match + on a node with the same type and more children + with 2 children more + is expected to match code s(:int, 1), :blah, s(:int, 1), and s(:sym, :something) + with 1 child more + is expected to match code s(:int, 1), :blah, and s(:int, 1) + on a node with the same type and exact number of children + is expected to match code s(:int, 1) and :blah + on a node with non-matching children + behaves like nonmatching + doesn't match + in any order + without ellipsis + with too few children + behaves like nonmatching + doesn't match + with matching children + behaves like multiple capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with too many children + behaves like nonmatching + doesn't match + captured + without ellipsis + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + invalid + doubled with ellipsis in wrong order + behaves like nonmatching + doesn't match + doubled with ellipsis + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + at the beginning of a sequence + behaves like invalid + is invalid + with an ellipsis inside and outside + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + nested + behaves like invalid + is invalid + containing ellipsis not at the end + behaves like invalid + is invalid + with an ellipsis + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + doubled + separated by fixed argument + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + separated by an ellipsis + behaves like multiple capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with a captured ellipsis + matching non sequential children + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + nested + behaves like multiple capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + matching all children + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + macros + with a pattern with captures + def_node_search + with a predicate name + when called on non-matching code + behaves like nonmatching + doesn't match + when it errors + raises an error with the right location + when called on matching code + is expected to match code nil, :foo, s(:sym, :hello), and s(:sym, :world) + without a predicate name + when called on non-matching code + returns an enumerator yielding nothing + when called on matching code + returns an enumerator yielding the captures + when the pattern contains keyword_params + returns an enumerator yielding the captures + when helper is called with default keyword_params + is overridden when calling the matcher + and no value is given to the matcher + uses the defaults + some defaults are not params + raises an error + when it errors + raises an error with the right location + def_node_matcher + when it errors + raises an error with the right location + when called on non-matching code + behaves like nonmatching + doesn't match + when called on matching code + is expected to eq :hello + with a pattern without captures + def_node_search + returns the method name + without a predicate name + when called on non-matching code + returns an enumerator yielding nothing + when called on matching code + returns an enumerator yielding the matches + when it errors + raises an error with the right location + with a predicate name + when called on non-matching code + behaves like nonmatching + doesn't match + when called on matching code + is expected to match code nil, :foo, s(:sym, :hello), and s(:sym, :world) + when it errors + raises an error with the right location + def_node_matcher + returns the method name + when called on matching code + is expected to match code :hello + when called on non-matching code + behaves like nonmatching + doesn't match + when it errors + raises an error with the right location + with a pattern with a namespaced call + is expected to match code :hello + when the value is not in the set + behaves like nonmatching + doesn't match + with a pattern with a constant + is expected to match code :hello + when the value is not in the set + behaves like nonmatching + doesn't match + bad syntax + with empty union subsequence in seq head + behaves like invalid + is invalid + with negated ellipsis + behaves like invalid + is invalid + with unmatched closing paren + behaves like invalid + is invalid + with leading comma in arg list + behaves like invalid + is invalid + with doubled ellipsis + is expected to match code "foo" + with unmatched opening curly + behaves like invalid + is invalid + with unsupported subsequence in seq head within union + behaves like invalid + is invalid + with unmatched closing curly + behaves like invalid + is invalid + with variadic unions where not supported + behaves like invalid + is invalid + with negated closing curly + behaves like invalid + is invalid + with unmatched opening paren and `...` + behaves like invalid + is invalid + with doubled comma in arg list + behaves like invalid + is invalid + with negated closing paren + behaves like invalid + is invalid + with empty intersection + behaves like invalid + is invalid + with empty parentheses + behaves like invalid + is invalid + with empty union + behaves like invalid + is invalid + with unmatched opening paren + behaves like invalid + is invalid + unions + variadic + with fixed terms + works for cases with fixed arity before and after union + works for cases with variadic terms after union + works for cases with variadic terms before and after union + with variadic terms + works for cases with fixed arity before and after union + works for cases with variadic terms after union + works for cases with variadic terms before and after union + multiple + works for complex cases + nested inside a sequence + is expected to match code s(:const, nil, :Const) and :method + with a nested sequence + is expected to match code s(:const, nil, :Const) and :method + at the top level + containing symbol literals + when the AST has a matching symbol + is expected to match code s(:send, nil, :obj) and :b + when the AST does not have a matching symbol + behaves like nonmatching + doesn't match + containing multiple [] + on a node which meets some requirements but not all + behaves like nonmatching + doesn't match + on a node which meets all requirements of the second [] + is expected to match code 2.4 + on a node which meets all requirements of the first [] + is expected to match code 3 + containing integer literals + is expected to match code s(:int, 10) and :abs + containing string literals + is expected to match code s(:str, "a") and :upcase + containing mixed node and literals + is expected to match code nil and :obj + nil + nil literals + is expected to match code + nil value in AST, use nil? method + is expected to match code nil and :foo + nil value in AST + behaves like nonmatching + doesn't match + against a node pattern (bug #5470) + behaves like nonmatching + doesn't match + node type + for a child + on a child with a different type + behaves like nonmatching + doesn't match + on a child litteral + behaves like nonmatching + doesn't match + on a child with the same type + is expected to match code s(:send, nil, :foo) and :bar + in seq head + on a child with a different type + behaves like nonmatching + doesn't match + on a node with the same type + is expected to match code s(:ivar, :@ivar), :+, and s(:int, 2) + caret (ascend) + inside a union + is expected to match code "abc" + used with a node type + which doesn't match + behaves like nonmatching + doesn't match + which matches + is expected to match code 1 + using unification to match self within parent + with self in the wrong position + behaves like nonmatching + doesn't match + with self in the right position + is expected to match code 2 + inside an intersection + is expected to match code 1 + within sequence + in head + is expected to match code 1 + of a sequence + is expected to match code 1 + not in head + is expected to match code s(:int, 1) and :inc + of a sequence + is expected to match code s(:int, 1) and :inc + repeated twice + is expected to match code 1 + captures on a wildcard + at the root level + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + in non-head position in a sequence + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + in head position in a sequence against nil (bug #5470) + behaves like nonmatching + doesn't match + in head position in a sequence against literal (bug #5470) + behaves like nonmatching + doesn't match + nested in any child + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + in a nested sequence + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + in head position in a sequence + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + literals + symbol literals + is expected to match code :foo + negative integer literals + is expected to match code -100 + negative float literals + is expected to match code -2.5 + single quoted string literals + is expected to match code "foo" + bare literal + on a node + behaves like nonmatching + doesn't match + on a matching literal + is expected to match code :bar + positive float literals + is expected to match code 1.0 + double quoted string literals + is expected to match code "foo" + descend + with an immediate match + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + nested + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + without match + behaves like nonmatching + doesn't match + with a literal match + is expected to match code s(:int, 1) and s(:array, + s(:array, + s(:int, 2), + s(:int, 3), + s(:array, + s(:array, + s(:int, 5)))), + s(:int, 4)) + with a match multiple levels, depth first + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + negation + on a symbol + with a matching symbol + behaves like nonmatching + doesn't match + with a non-matching symbol, but too many children + behaves like nonmatching + doesn't match + with a non-matching symbol + is expected to match code s(:send, nil, :obj) and :xyz + on a set + with a matching value + behaves like nonmatching + doesn't match + with a non-matching value + is expected to match code :@a and s(:int, 3) + on a sequence + with a node with non-matching children + is expected to match code :@b and s(:int, 1) + with a node of different type + is expected to match code :@@a and s(:int, 1) + with a matching node + behaves like nonmatching + doesn't match + when nested in complex ways + with (send str :<< str) + behaves like nonmatching + doesn't match + with (send int :- int) + is expected to match code s(:int, 1), :-, and s(:int, 1) + with (send str :+ (send str :to_i)) + is expected to match code s(:str, "abc"), :+, and s(:send, + s(:str, "1"), :to_i) + on a string + with a non-matching symbol + is expected to match code s(:str, "bar") and :upcase + with a matching string + behaves like nonmatching + doesn't match + on square brackets + with a node which meets all requirements of [] + behaves like nonmatching + doesn't match + with a node which meets only 1 requirement of [] + is expected to match code 1 + funcalls + with multiple arguments + is expected to match code s(:str, "c"), "a", and "d" + without extra arguments + is expected to match code :a and s(:int, 1) + with one argument + is expected to match code s(:str, "foo") and "foo" + captures within union + within nested sequences + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with a different number of captures in each branch + behaves like invalid + is invalid + with complex nesting + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + on simple subpatterns + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + simple sequence + on a node with the same type and non-matching children + with non-matching selector + behaves like nonmatching + doesn't match + with non-matching receiver type + behaves like nonmatching + doesn't match + with a nested sequence in non-head position + is expected to match code s(:send, + s(:send, nil, :obj), :a) and :b + on a node with a different type + behaves like nonmatching + doesn't match + on a node with too many children + behaves like nonmatching + doesn't match + with a nested sequence in head position + behaves like invalid + is invalid + on a node with the same type and matching children + is expected to match code s(:int, 1), :+, and s(:int, 1) + params + when captured + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + when negated, with a nonmatching value + is expected to match code s(:const, + s(:const, nil, :Namespace), :B) and :A + when inside a union, with a matching value + is expected to match code s(:int, 10) and 10 + in root position + is expected to match code s(:int, 10) and s(:int, 10) + in root position + is expected to match code s(:int, 10) and # + when negated, with a matching value + behaves like nonmatching + doesn't match + as named parameters + when provided as argument to match + is expected to match code s(:int, 10) and {:foo=>#} + when extra are provided + raises an ArgumentError + when not provided + raises an ArgumentError + when preceded by ... + is expected to match code s(:send, + s(:int, 1), :+, + s(:int, 10)) and s(:int, 10) + when preceded by $... + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + when inside a union, with a nonmatching value + behaves like nonmatching + doesn't match + without explicit number + is expected to match code s(:const, + s(:const, nil, :Namespace), :A), :A, and s(:const, nil, :Namespace) + when inside an intersection + is expected to match code s(:int, 20), 10, and 20 + param number zero + in a position which does not match original target node + behaves like nonmatching + doesn't match + in a position which matches original target node + is expected to match code 1 + in a nested sequence + is expected to match code s(:send, + s(:send, + s(:int, 5), :dec), :inc), :inc, and :dec + predicates + in root position + is expected to match code s(:int, 1) and :inc + with name containing a numeral + is expected to match code s(:int, 1) and :inc + applied to an integer for which the predicate is false + behaves like nonmatching + doesn't match + when in last-child position, but all children have already been matched + behaves like nonmatching + doesn't match + with a constant argument + for which the predicate is true + is expected to match code s(:int, 1), :+, and s(:int, 2) + for which the predicate is false + behaves like nonmatching + doesn't match + with an expression argument + for which the predicate is false + behaves like nonmatching + doesn't match + for which the predicate is true + is expected to match code s(:int, 2), :+, and s(:float, 2.0) + when negated + is expected to match code s(:int, 1) and :inc + with multiple arguments + for which the predicate is false + behaves like nonmatching + doesn't match + for which the predicate is true + is expected to match code s(:str, "c"), "a", and "d" + with a named argument + for which the predicate is false + behaves like nonmatching + doesn't match + with extra arguments + raises an error + when not given + raises an error + for which the predicate is true + is expected to match code s(:send, + s(:int, 1), :+, + s(:int, 2)) and {:param=>1} + applied to an integer for which the predicate is true + is expected to match code s(:int, 1) and :inc + when captured + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + at head position of a sequence + is expected to match code s(:int, 1) and :inc + with one extra argument + for which the predicate is true + is expected to match code s(:send, + s(:int, 1), :+, + s(:int, 2)) and 1 + for which the predicate is false + behaves like nonmatching + doesn't match + bare node type + #pattern + returns the pattern + on a node with the same type + is expected to match code s(:send, nil, :obj) and :method + yaml compatibility + is expected to match code s(:send, nil, :obj) and :method + on a node with a matching, hyphenated type + is expected to match code s(:lvasgn, :a), :+, and s(:int, 1) + marshal compatibility + is expected to match code s(:send, nil, :obj) and :method + #to_s + is instructive + #dup + is expected to match code s(:send, nil, :obj) and :method + #== + returns true iff the patterns are similar + on a node with a different type + behaves like nonmatching + doesn't match + comments + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + regexp + matches symbols or strings + .descend + yields the given argument if it is not a Node + yields all children depth first + wildcards + unnamed wildcards + within a sequence with other patterns intervening + is expected to match code :@abc and s(:int, 22) + within a sequence + is expected to match code nil and :Const + at the root level + is expected to match code s(:sclass, + s(:self), + s(:def, :something, + s(:args), + s(:int, 1))) and :freeze + negated + behaves like nonmatching + doesn't match + in head position of a sequence + is expected to match code s(:int, 1), :+, and s(:send, nil, :a) + named wildcards + within a union + confined to the union + with partial unification + matching the free branch + is expected to match code s(:int, 2) and s(:int, 1) + matching the unified branch + is expected to match code s(:int, 5) and s(:int, 5) + that can not be unified + behaves like nonmatching + doesn't match + without unification + is expected to match code s(:int, 2) and s(:int, 1) + with a preceding unifying constraint + that can not be unified + behaves like nonmatching + doesn't match + matching a branch + is expected to match code s(:int, 2) and s(:array, + s(:int, 2), + s(:int, 1)) + with a succeeding unifying constraint + with branches without the wildcard + encountered first + behaves like invalid + is invalid + encountered after + behaves like invalid + is invalid + with all branches with the wildcard + that can not be unified + behaves like nonmatching + doesn't match + matching another branch + is expected to match code s(:array, + s(:int, 2), + s(:int, 1)) and s(:int, 2) + matching the first branch + is expected to match code s(:array, + s(:int, 1), + s(:int, 2)) and s(:int, 2) + in head position of a sequence + is expected to match code s(:int, 1), :+, and s(:send, nil, :a) + within a sequence + unifying the node type with an argument + is expected to match code s(:send, nil, :obj) and :send + with values which cannot be unified + behaves like nonmatching + doesn't match + with values which can be unified + is expected to match code s(:int, 5), :+, and s(:int, 5) + at the root level + is expected to match code s(:sclass, + s(:self), + s(:def, :something, + s(:args), + s(:int, 1))) and :freeze + within a sequence with other patterns intervening + is expected to match code :@abc and s(:int, 22) + captures which also perform a match + on [] + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + on a node type + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + on a set + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + when nested + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + on a literal + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + on a sequence + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + captures on ... + with a remaining [] at the end + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + after a child + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with a remaining literal at the end + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with a remaining set at the end + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with a remaining capture at the end + behaves like multiple capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with a remaining wildcard at the end + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with a remaining sequence at the end + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with no remaining pattern at the end + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + with a remaining node type at the end + behaves like single capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with remaining patterns at the end + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + at the very beginning of a sequence + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + ellipsis + with a nested sequence at the end, but no remaining child + behaves like nonmatching + doesn't match + with a set at the end, but no remaining child to match it + behaves like nonmatching + doesn't match + with [] at the end, but no remaining child to match it + behaves like nonmatching + doesn't match + with a wildcard at the end, but no remaining child to match it + behaves like nonmatching + doesn't match + preceding a capture + behaves like single capture + yields captured value(s) and returns true if there is a block + returns captured values if there is no block + preceding multiple captures + behaves like multiple capture + returns captured values if there is no block + yields captured value(s) and returns true if there is a block + with a nodetype at the end, but no remaining child to match it + behaves like nonmatching + doesn't match + at the very beginning of a sequence + is expected to match code s(:int, 10), :*, and s(:int, 1) + +RuboCop::AST::Node + #class_definition? + without inheritance + matches + with Class.new + matches + when using numbered parameter + matches + constant defined as Struct without block + does not match + with object singleton class + matches + with self singleton class + matches + with Struct + matches + when using numbered parameter + matches + with inheritance + matches + with ::ClassName + matches + namespaced class + matches + #recursive_basic_literal? + behaves like non literal + returns false for `/.#{some_method_call}/` + behaves like literal + returns true for `(false or true)` + behaves like literal + returns true for `false` + behaves like non literal + returns false for `(x == false)` + behaves like literal + returns true for `(false && true)` + behaves like literal + returns true for `/./` + behaves like non literal + returns false for `(x or false)` + behaves like literal + returns true for `%r{abx}ixo` + behaves like literal + returns true for `(false <=> true)` + behaves like literal + returns true for `{ :a => 1, :b => 2 }` + behaves like non literal + returns false for `some_method_call` + behaves like non literal + returns false for `{ some_method_call => :sym }` + behaves like non literal + returns false for `%r{abx#{foo}}ixo` + behaves like literal + returns true for `(1)` + behaves like literal + returns true for `!true` + behaves like literal + returns true for `1.0` + behaves like non literal + returns false for `some_method_call(x, y)` + behaves like literal + returns true for `[1, 2, 3]` + behaves like non literal + returns false for `{ :sym => some_method_call }` + behaves like literal + returns true for `{ a: 1, b: 2 }` + behaves like literal + returns true for `'str'` + behaves like literal + returns true for `"#{2}"` + behaves like literal + returns true for `1` + behaves like non literal + returns false for `[some_method_call]` + behaves like non literal + returns false for `(x && false)` + behaves like literal + returns true for `nil` + #module_definition? + nested modules + matches + included module definition + matches + using module keyword + matches + namespaced modules + matches + with Module.new + matches + when using numbered parameter + matches + prepend Module.new + matches + with ::ModuleName + matches + #numeric_type? + when string literal + is true + when complex literal whose imaginary part is a rational + is true + when float literal + is true + when integer literal + is true + when complex literal + is true + when rational literal + is true + #struct_constructor? + struct definition with a block + matches + struct definition without block + does not match + ::Struct + matches + #class_constructor? + module definition with a block + matches + class definition on outer scope + matches + class definition with a block + matches + class definition + does not match + #argument_type? + method arguments + returns true for all argument types + block arguments + returns true for all argument types + #value_used? + within a singleton class node + is always true + within a while node + is true only for the condition + within a class definition node + is always true + within an array literal + at the top level + is always false + assigned to an ivar + is always true + within a method call node + is always true + at the top level + is false + within an if...else..end node + at the top level + is true only for the condition + nested in a method call + is always true + at the end of a block + is always true + within a module definition node + is always true + #pure? + for an ivar assignment + returns false + for a regexp + with no interpolation + returns true + with interpolated segments + returns false + with options + returns true + for a class definition + returns false + for a nested if + where the innermost descendants are local vars and literals + returns true + where one branch contains a method call + returns false + where one branch contains an assignment statement + returns false + for a cvar assignment + returns false + for a module definition + returns false + for a hash literal + with only literal children + returns true + which contains a method call + returns false + for an integer literal + returns true + for an array literal + with only literal children + returns true + which contains a method call + returns false + for a method call + returns false + for an lvar assignment + returns false + for a gvar assignment + returns false + sibling_access + returns trivial values for a root node + for a node with siblings + returns the expected values + for a single child + returns the expected values + #parent_module_name + when node nested in a class << exp + is expected to be nil + when node on top level + is expected to eq "Object" + when node on module + is expected to eq "Foo" + when node nested in an unknown block + is expected to be nil + when node on class in singleton class + is expected to eq "Foo::#::Bar" + when node on singleton class + is expected to eq "Foo::#" + #conditional? + when `case` node + is true + when post condition loop node + is false + when `while` node + is true + when `case_match` node + is true + when `if` node + is true + when `until` node + is true + +RuboCop::AST::ProcessedSource + token enumerables + #each_token + yields all tokens + #find_token + yields correct token + yields nil when there is no match + #path + is the path passed to .new + #tokens + has an array of tokens + #tokens_within + accepts Node as an argument + returns tokens for node + when heredoc as argument is present + returns tokens for heredoc node + returns tokens for node after heredoc + returns tokens for node before heredoc + #first_token_of + accepts Node as an argument + returns first token for node + valid_syntax? + when the source could not be parsed due to encoding error + returns false + when the source is completely valid + returns true + when the source is valid but has some warning diagnostics + returns true + when the source itself is valid encoding but includes strange encoding literals that are accepted by MRI + returns true + when the source is invalid + returns false + when a line starts with an integer literal + tokenizes the source correctly + .from_file + raises a Errno::ENOENT when the file does not exist + when the file exists + sets the file path to the instance's #path + returns an instance of ProcessedSource + #[] + when an index is passed + returns the line + when start index and length are passed + returns the array of lines + when a range is passed + returns the array of lines + #blank? + with source with content + returns false + with source of no content + returns true + #start_with? + with blank source + returns false + with present source + returns false when passed string that does not start source + returns true when passed string that starts source + #last_token_of + returns last token for node + accepts Node as an argument + #following_line + returns source of line after token + #comments + is an array of comments + when the source is invalid + returns [] + #file_path + returns file path + #buffer + is a source buffer + #ast + is the root node of AST + #lines + contains lines as string without linefeed + is an array + has same number of elements as line count + #parser_error + when the source lacks encoding comment and is really utf-8 encoded but has been read as US-ASCII + is nil + when the source could not be parsed due to encoding error + returns the error + when the source was properly parsed + is nil + #preceding_line + returns source of line before token + with heavily commented source + #comment_at_line + returns the comment at the given line number + returns nil if line has no comment + #find_comment + yields nil when there is no match + yields correct comment + #each_comment + yields all comments + #comments_before_line + returns comments on or before given line + #line_with_comment? + returns true for lines with comments + returns false for lines without comments + #each_comment_in_lines + yields the comments + #contains_comment? + provided a multiline source_range with at least one line with comment + is expected to equal true + provided source_range on line with comment + is expected to equal true + provided source_range on line without comment + is expected to equal false + provided source_range on comment line + is expected to equal true + +RuboCop::AST::ForwardArgsNode + when using Ruby 2.7 or newer + #to_a + is expected to contain exactly (be forward arg type) + +RuboCop::AST::WhenNode + #body + with a then keyword + is expected to be sym type + without a then keyword + is expected to be array type + .new + is expected to be a kind of RuboCop::AST::WhenNode + #each_condition + when passed a block + yields all the conditions + when not passed a block + is expected to be a kind of Enumerator + #conditions + with a single condition + is expected to eq 1 + is expected to all be literal + with a multiple conditions + is expected to eq 3 + is expected to all be literal + #then? + with a then keyword + is expected to be then + without a then keyword + is expected not to be then + #branch_index + is expected to eq 0 + is expected to eq 1 + is expected to eq 2 RuboCop::AST::YieldNode - #block_node - is expected to be nil - #block_argument? - is expected not to be block argument #self_receiver? is expected not to be self receiver #comparison_method? is expected not to be comparison method - #dot? - is expected not to be dot - #last_argument - with multiple mixed arguments - is expected to be splat type - with multiple literal arguments - is expected to be sym type - with a single literal argument - is expected to be sym type - with a single splat argument - is expected to be splat type - with no arguments - is expected to be nil - #const_receiver? - is expected not to be const receiver - #parenthesized? + #command? + when argument is a symbol + is expected to be command :yield + when argument is a string + is expected to be command "yield" + #splat_argument? + with a splat argument + is expected to be splat argument with no arguments - when not using parentheses - is expected not to be parenthesized - when using parentheses - is expected to be parenthesized - with arguments - when using parentheses - is expected to be parenthesized - when not using parentheses - is expected not to be parenthesized - #setter_method? - is expected not to be setter method - #camel_case_method? - is expected not to be camel case method - #double_colon? - is expected not to be double colon - #assignment_method? - is expected not to be assignment method + is expected not to be splat argument + with regular arguments + is expected not to be splat argument + with mixed arguments + is expected to be splat argument #arguments with a single literal argument is expected to eq 1 + with no arguments + is expected to be empty + with a single splat argument + is expected to eq 1 with multiple mixed arguments is expected to eq 2 with multiple literal arguments is expected to eq 2 + #arguments? + with a single literal argument + is expected to be arguments + with multiple literal arguments + is expected to be arguments + with multiple mixed arguments + is expected to be arguments with a single splat argument - is expected to eq 1 + is expected to be arguments with no arguments - is expected to be empty + is expected not to be arguments + #const_receiver? + is expected not to be const receiver + #double_colon? + is expected not to be double colon #first_argument + with no arguments + is expected to be nil + with a single literal argument + is expected to be sym type with multiple literal arguments is expected to be sym type with multiple mixed arguments is expected to be sym type with a single splat argument is expected to be splat type - with no arguments - is expected to be nil - with a single literal argument - is expected to be sym type - #operator_method? - is expected not to be operator method - #macro? - is expected not to be macro - #command? - when argument is a string - is expected to be command "yield" - when argument is a symbol - is expected to be command :yield + .new + is expected to be a kind of RuboCop::AST::YieldNode + #setter_method? + is expected not to be setter method + #method_name + is expected to eq :yield #method? when message matches when argument is a string @@ -1134,477 +2420,1026 @@ when argument is a symbol is expected to be method :yield when message does not match - when argument is a symbol - is expected not to be method :foo when argument is a string is expected not to be method "foo" - #method_name - is expected to eq :yield - #block_literal? - is expected not to be block literal + when argument is a symbol + is expected not to be method :foo + #receiver + is expected to be nil + #operator_method? + is expected not to be operator method + #implicit_call? + is expected not to be implicit call + #macro? + is expected not to be macro + #dot? + is expected not to be dot + #camel_case_method? + is expected not to be camel case method + #last_argument + with no arguments + is expected to be nil + with multiple mixed arguments + is expected to be splat type + with a single splat argument + is expected to be splat type + with a single literal argument + is expected to be sym type + with multiple literal arguments + is expected to be sym type + #predicate_method? + is expected not to be predicate method #bang_method? is expected not to be bang method + #block_literal? + is expected not to be block literal + #assignment_method? + is expected not to be assignment method + #parenthesized? + with no arguments + when using parentheses + is expected to be parenthesized + when not using parentheses + is expected not to be parenthesized + with arguments + when using parentheses + is expected to be parenthesized + when not using parentheses + is expected not to be parenthesized + #block_node + is expected to be nil + #block_argument? + is expected not to be block argument + +RuboCop::AST::ArrayNode + #bracketed? + with square brackets + is expected to be bracketed + unbracketed + is expected to be nil + with a percent literal + is expected to be bracketed + #each_value + without block + is expected to be a kind of Enumerator + with block + is expected to eq ["(int 1)", "(int 2)", "(int 3)"] + is expected to be a kind of RuboCop::AST::ArrayNode + #values + with an array of literals + is expected to eq 3 + is expected to all be literal + with an array of variables + is expected to all be send type + is expected to eq 2 + with an empty array + is expected to be empty + #percent_literal? + with square brackets + is expected not to be percent literal :string + is expected not to be percent literal + is expected not to be percent literal :symbol + with a string percent literal + is expected to be percent literal + is expected to be percent literal :string + is expected not to be percent literal :symbol + with a symbol percent literal + is expected to be percent literal :symbol + is expected not to be percent literal :string + is expected to be percent literal + #square_brackets? + with square brackets + is expected to be square brackets + with a percent literal + is expected not to be square brackets + .new + is expected to be a kind of RuboCop::AST::ArrayNode + +RuboCop::AST::OpAsgnNode + #operator + with -= + is expected to eq :- + with |= + is expected to eq :| + with *= + is expected to eq :* + with &= + is expected to eq :& + with += + is expected to eq :+ + with %= + is expected to eq :% + with **= + is expected to eq :** + with /= + is expected to eq :/ + #expression + is expected to eq s(:send, nil, :value) + .new + with an `op_asgn_node` node + is expected to be a kind of RuboCop::AST::OpAsgnNode + #assignment_node + is expected to be a kind of RuboCop::AST::AsgnNode + #name + is expected to eq :var + +RuboCop::AST::AliasNode + .new + is expected to be a kind of RuboCop::AST::AliasNode + #old_identifier + is expected to be sym type + is expected to eq :bar + #new_identifier + is expected to be sym type + is expected to eq :foo + +RuboCop::AST::SelfClassNode + #identifier + is expected to be self type + #body + with a multi-expression body + is expected to be begin type + with a single expression body + is expected to be send type + with an empty body + is expected to be nil + .new + is expected to be a kind of RuboCop::AST::SelfClassNode + +RuboCop::AST::StrNode + #heredoc? + with a heredoc + is expected to be heredoc + with a string with interpolation + is expected not to be heredoc + with a normal string + is expected not to be heredoc + .new + with a heredoc + is expected to be a kind of RuboCop::AST::StrNode + with a normal string + is expected to be a kind of RuboCop::AST::StrNode + with a string with interpolation + is expected to be a kind of RuboCop::AST::StrNode + #character_literal? + with a normal string literal + is expected not to be character literal + with a heredoc + is expected not to be character literal + with a character literal + is expected to be character literal + +RuboCop::AST::RuboCopCompatibility + when ran from an incompatible version of Rubocop + issues a warning + when ran from a compatible version of Rubocop + issues a warning + +RuboCop::AST::ReturnNode + behaves like wrapped arguments node + .new + without arguments + is expected to be a kind of RuboCop::AST::ReturnNode + with arguments + is expected to be a kind of RuboCop::AST::ReturnNode + #arguments + with a single argument + is expected to eq 1 + with a single argument and braces + is expected to eq 1 + with a single splat argument + is expected to eq 1 + with multiple literal arguments + is expected to eq 2 + with no arguments + is expected to be empty + with no arguments and braces + is expected to be empty + +RuboCop::AST::HashNode + .new + is expected to be a kind of RuboCop::AST::HashNode + #keys + with a hash with symbol keys + is expected to all be sym type + is expected to eq 3 + with an empty hash + is expected to be empty + with a hash with string keys + is expected to all be str type + is expected to eq 2 + #mixed_delimiters? + when all pairs are using a hash rocket delimiter + is expected not to be mixed delimiters + when pairs are using different delimiters + is expected to be mixed delimiters + when all pairs are using a colon delimiter + is expected not to be mixed delimiters + #values + with a hash with string keys + is expected to eq 2 + is expected to all be send type + with an empty hash + is expected to be empty + with a hash with literal values + is expected to eq 3 + is expected to all be literal + #each_pair + when not passed a block + is expected to be a kind of Enumerator + when passed a block + yields all the pairs + #pairs + with an empty hash + is expected to be empty + with a hash of variables + is expected to all be pair type + is expected to eq 2 + with a hash of literals + is expected to all be pair type + is expected to eq 3 + #pairs_on_same_line? + with all pairs on the same line + is expected to be pairs on same line + with no pairs on the same line + is expected not to be pairs on same line + with some pairs on the same line + is expected to be pairs on same line + #each_key + when passed a block + yields all the pairs + when not passed a block + is expected to be a kind of Enumerator + #braces? + with braces + is expected to be braces + as an argument with braces + is expected to be braces + as an argument with no braces + is expected not to be braces + #empty? + with a hash containing a keyword splat + is expected not to be empty + with a hash containing pairs + is expected not to be empty + with an empty hash + is expected to be empty + #each_value + when not passed a block + is expected to be a kind of Enumerator + when passed a block + yields all the pairs + +RuboCop::AST::LambdaNode #receiver is expected to be nil + #method_name + is expected to eq :lambda + #arguments + is expected to eq 2 + +RuboCop::AST::ArgNode + #name + with a block + is expected to eq :x + with a shadow argument + is expected to eq :x + with argument forwarding + with Ruby >= 3.0 + is expected to be nil + with Ruby >= 2.7 + is expected to be nil + with an optional argument + is expected to eq :x + with a double splatted argument + is expected to eq :x + with a regular argument + is expected to eq :x + with a nameless splatted argument + is expected to be nil + with a splatted argument + is expected to eq :x + with an optional keyword argument + is expected to eq :x + with a block argument + is expected to eq :x + with a keyword argument + is expected to eq :x + with a nameless double splatted argument + is expected to be nil .new - is expected to be a kind of RuboCop::AST::YieldNode - #predicate_method? - is expected not to be predicate method - #splat_argument? - with mixed arguments - is expected to be splat argument - with regular arguments - is expected not to be splat argument + with a block + is expected to be a kind of RuboCop::AST::ArgNode + with a splatted argument + is expected to be a kind of RuboCop::AST::ArgNode + with an optional keyword argument + is expected to be a kind of RuboCop::AST::ArgNode + with a method definition + is expected to be a kind of RuboCop::AST::ArgNode + with argument forwarding + with Ruby >= 3.0 + is expected to be a kind of RuboCop::AST::ArgNode + with Ruby >= 2.7 + is expected to be a kind of RuboCop::AST::ArgNode + with a lambda literal + is expected to be a kind of RuboCop::AST::ArgNode + with a block argument + is expected to be a kind of RuboCop::AST::ArgNode + with a keyword argument + is expected to be a kind of RuboCop::AST::ArgNode + with a double splatted argument + is expected to be a kind of RuboCop::AST::ArgNode + with an optional argument + is expected to be a kind of RuboCop::AST::ArgNode + with a shadow argument + is expected to be a kind of RuboCop::AST::ArgNode + #default? + with a regular argument + is expected to equal false + with a double splatted argument + is expected to equal false + with a splatted argument + is expected to equal false + with argument forwarding + with Ruby >= 3.0 + is expected to equal false + with Ruby >= 2.7 + is expected to equal false + with a block + is expected to equal false + with an optional argument + is expected to equal true + with a shadow argument + is expected to equal false + with a block argument + is expected to equal false + with an optional keyword argument + is expected to equal true + #default_value + with a splatted argument + is expected to be nil + with a double splatted argument + is expected to be nil + with a block argument + is expected to be nil + with an optional keyword argument + is expected to eq s(:int, 42) + with argument forwarding + with Ruby >= 2.7 + is expected to be nil + with Ruby >= 3.0 + is expected to be nil + with a regular argument + is expected to be nil + with a block + is expected to be nil + with an optional argument + is expected to eq s(:int, 42) + with a shadow argument + is expected to be nil + +RuboCop::AST::BlockNode + #braces? + when enclosed in braces + is expected to be braces + when enclosed in do-end keywords + is expected not to be braces + #opening_delimiter + when enclosed in braces + is expected to eq "{" + when enclosed in do-end keywords + is expected to eq "do" + #arguments + with multiple mixed arguments + is expected to eq 2 + with destructured arguments + is expected to eq 2 + >= Ruby 2.7 + using numbered parameters + is expected to be empty with no arguments - is expected not to be splat argument - with a splat argument - is expected to be splat argument + is expected to be empty + with a single literal argument + is expected to eq 1 + with a single splat argument + is expected to eq 1 + #multiline? + when block is on several lines + is expected to be multiline + when block is on a single line + is expected not to be multiline + .new + is expected to be a kind of RuboCop::AST::BlockNode #arguments? - with multiple mixed arguments + >= Ruby 2.7 + using numbered parameters + is expected not to be arguments + with destructuring arguments is expected to be arguments - with multiple literal arguments + with a single argument is expected to be arguments - with a single literal argument + with multiple mixed arguments is expected to be arguments + with no arguments + is expected not to be arguments with a single splat argument is expected to be arguments + #delimiters + when enclosed in do-end keywords + is expected to eq ["do", "end"] + when enclosed in braces + is expected to eq ["{", "}"] + #argument_list + all argument types + is expected to eq [:a, :b, :c, :d, :e, :f, :g, :h, :i] + >= Ruby 2.7 + using numbered parameters + with sequential params + is expected to eq [:_1, :_2] + with skipped params + is expected to eq [:_1, :_2, :_3, :_4, :_5, :_6, :_7] with no arguments - is expected not to be arguments - #implicit_call? - is expected not to be implicit call + is expected to be empty + #void_context? + when block method is not each + is expected not to be void context + when block method is tap + is expected to be void context + when block method is each + is expected to be void context + #keywords? + when enclosed in braces + is expected not to be keywords + when enclosed in do-end keywords + is expected to be keywords + #single_line? + when block is on a single line + is expected to be single line + when block is on several lines + is expected not to be single line + #closing_delimiter + when enclosed in braces + is expected to eq "}" + when enclosed in do-end keywords + is expected to eq "end" + #receiver + with dot operator call + is expected to eq "foo" + with safe navigation operator call + is expected to eq "foo" + #lambda? + when block belongs to a method lambda + is expected to be lambda + when block belongs to a stabby lambda + is expected to be lambda + when block belongs to a non-lambda method + is expected not to be lambda + +RuboCop::AST::AndAsgnNode + #operator + is expected to eq :"&&" + #expression + is expected to eq s(:send, nil, :value) + .new + is expected to be a kind of RuboCop::AST::AndAsgnNode + #name + is expected to eq :var + #assignment_node + is expected to be a kind of RuboCop::AST::AsgnNode + +RuboCop::AST::AsgnNode + #name + with a `gvasgn` node + is expected to eq :$var + with a `ivasgn` node + is expected to eq :@var + with a `lvasgn` node + is expected to eq :var + with a `cvasgn` node + is expected to eq :@@var + #expression + with a `cvasgn` node + is expected to eq s(:send, nil, :value) + with a `lvasgn` node + is expected to eq s(:send, nil, :value) + with a `ivasgn` node + is expected to eq s(:send, nil, :value) + with a `gvasgn` node + is expected to eq s(:send, nil, :value) + .new + with a `lvasgn` node + is expected to be a kind of RuboCop::AST::AsgnNode + with a `gvasgn` node + is expected to be a kind of RuboCop::AST::AsgnNode + with a `cvasgn` node + is expected to be a kind of RuboCop::AST::AsgnNode + with a `ivasgn` node + is expected to be a kind of RuboCop::AST::AsgnNode + +RuboCop::AST::Ext::Range + #line_span + accepts an `exclude_end` keyword argument + returns the range of lines a range occupies + +RuboCop::AST::WhileNode + .new + with a statement while + is expected to be a kind of RuboCop::AST::WhileNode + with a modifier while + is expected to be a kind of RuboCop::AST::WhileNode + #post_condition_loop? + with a modifier while + is expected to be post condition loop + with a statement while + is expected not to be post condition loop + #inverse_keyword + is expected to eq "until" + #do? + with a do keyword + is expected to be do + without a do keyword + is expected not to be do + #loop_keyword? + with a statement while + is expected to be loop keyword + with a modifier while + is expected to be loop keyword + #keyword + is expected to eq "while" + +RuboCop::AST::ClassNode + .new + is expected to be a kind of RuboCop::AST::ClassNode + #body + with a single expression body + is expected to be send type + with an empty body + is expected to be nil + with a multi-expression body + is expected to be begin type + #identifier + is expected to be const type + #parent_class + when no parent class is specified + is expected to be nil + when a parent class is specified + is expected to be const type + +RuboCop::AST::NextNode + behaves like wrapped arguments node + #arguments + with no arguments and braces + is expected to be empty + with a single splat argument + is expected to eq 1 + with a single argument + is expected to eq 1 + with multiple literal arguments + is expected to eq 2 + with no arguments + is expected to be empty + with a single argument and braces + is expected to eq 1 + .new + with arguments + is expected to be a kind of RuboCop::AST::NextNode + without arguments + is expected to be a kind of RuboCop::AST::NextNode RuboCop::AST::PairNode - #colon? - when using a colon delimiter - is expected to be colon - when using a hash rocket delimiter - is expected not to be colon - #value_on_new_line? - when value starts on a new line - is expected to be value on new line - when pair is on a single line - is expected not to be value on new line - when value spans multiple lines - is expected not to be value on new line - #value - is expected to be int type #key_delta with alignment set to :right when using colon delimiters + when receiver key is behind + when second pair is a keyword splat + is expected to eq 0 + when both pairs are reail pairs + is expected to eq -2 when receiver key is ahead when second pair is a keyword splat is expected to eq 0 when both pairs are explicit pairs is expected to eq 2 when both keys are on the same line - when both pairs are explicit pairs - is expected to eq 0 when second pair is a keyword splat is expected to eq 0 - when keys are aligned - when second pair is a keyword splat + when both pairs are explicit pairs is expected to eq 0 + when keys are aligned when both pairs are explicit pairs is expected to eq 0 - when receiver key is behind - when both pairs are reail pairs - is expected to eq -2 when second pair is a keyword splat is expected to eq 0 when using hash rocket delimiters - when receiver key is ahead - when both pairs are explicit pairs - is expected to eq 2 - when second pair is a keyword splat - is expected to eq 0 when keys are aligned when second key is a keyword splat is expected to eq 0 when both keys are explicit keys is expected to eq 0 - when both keys are on the same line - when both pairs are explicit pairs - is expected to eq 0 + when receiver key is behind when second pair is a keyword splat is expected to eq 0 - when receiver key is behind when both pairs are explicit pairs is expected to eq -2 + when both keys are on the same line + when second pair is a keyword splat + is expected to eq 0 + when both pairs are explicit pairs + is expected to eq 0 + when receiver key is ahead + when both pairs are explicit pairs + is expected to eq 2 when second pair is a keyword splat is expected to eq 0 with alignment set to :left when using hash rocket delimiters - when both keys are on the same line + when receiver key is behind when second pair is a keyword splat - is expected to eq 0 + is expected to eq -2 when both pairs are explicit pairs - is expected to eq 0 + is expected to eq -2 when receiver key is ahead when both pairs are explicit pairs is expected to eq 2 when second pair is a keyword splat is expected to eq 2 - when keys are aligned - when second key is a keyword splat + when both keys are on the same line + when second pair is a keyword splat + is expected to eq 0 + when both pairs are explicit pairs is expected to eq 0 + when keys are aligned when both keys are explicit keys is expected to eq 0 - when receiver key is behind + when second key is a keyword splat + is expected to eq 0 + when using colon delimiters + when keys are aligned when both pairs are explicit pairs - is expected to eq -2 + is expected to eq 0 when second pair is a keyword splat - is expected to eq -2 - when using colon delimiters + is expected to eq 0 when receiver key is behind when both pairs are reail pairs is expected to eq -2 when second pair is a keyword splat is expected to eq -2 - when keys are aligned - when both pairs are explicit pairs - is expected to eq 0 + when both keys are on the same line when second pair is a keyword splat is expected to eq 0 - when receiver key is ahead when both pairs are explicit pairs - is expected to eq 2 + is expected to eq 0 + when receiver key is ahead when second pair is a keyword splat is expected to eq 2 - when both keys are on the same line when both pairs are explicit pairs - is expected to eq 0 - when second pair is a keyword splat - is expected to eq 0 - #delimiter - when using a hash rocket delimiter + is expected to eq 2 + #value_on_new_line? + when pair is on a single line + is expected not to be value on new line + when value starts on a new line + is expected to be value on new line + when value spans multiple lines + is expected not to be value on new line + #inverse_delimiter + when using a colon delimiter is expected to eq " => " is expected to eq "=>" - when using a colon delimiter - is expected to eq ":" - is expected to eq ": " - .new - is expected to be a kind of RuboCop::AST::PairNode - #hash_rocket? when using a hash rocket delimiter - is expected to be hash rocket - when using a colon delimiter - is expected not to be hash rocket - #value_omission? - when using hash value omission - is expected to be value omission - when not using hash value omission - is expected not to be value omission + is expected to eq ": " + is expected to eq ":" #value_delta - when using hash rocket delimiters - when receiver value is ahead - is expected to eq 2 - when receiver value is behind - is expected to eq -2 + when using colon delimiters when both pairs are on the same line is expected to eq 0 + when receiver value is ahead + is expected to eq 2 when values are aligned when second pair is a keyword splat is expected to eq 0 when both pairs are explicit pairs is expected to eq 0 - when using colon delimiters when receiver value is behind is expected to eq -2 + when using hash rocket delimiters + when receiver value is behind + is expected to eq -2 + when both pairs are on the same line + is expected to eq 0 + when receiver value is ahead + is expected to eq 2 when values are aligned when both pairs are explicit pairs is expected to eq 0 when second pair is a keyword splat is expected to eq 0 - when receiver value is ahead - is expected to eq 2 - when both pairs are on the same line - is expected to eq 0 + #value_omission? + when not using hash value omission + is expected not to be value omission + when using hash value omission + is expected to be value omission + #colon? + when using a colon delimiter + is expected to be colon + when using a hash rocket delimiter + is expected not to be colon + #delimiter + when using a colon delimiter + is expected to eq ":" + is expected to eq ": " + when using a hash rocket delimiter + is expected to eq "=>" + is expected to eq " => " + .new + is expected to be a kind of RuboCop::AST::PairNode + #value + is expected to be int type #key when using a string key is expected to be str type when using a symbol key is expected to be sym type + #hash_rocket? + when using a hash rocket delimiter + is expected to be hash rocket + when using a colon delimiter + is expected not to be hash rocket #same_line? - when pairs are on separate lines + when both pairs are on the same line when both pairs are explicit pairs - is expected not to be same line s(:pair, + is expected to be same line s(:pair, s(:sym, :b), s(:int, 2)) - when last pair is a keyword splat - is expected not to be same line s(:kwsplat, - s(:send, nil, :foo)) - when both pairs are on the same line when both pair is a keyword splat is expected to be same line s(:kwsplat, s(:send, nil, :foo)) + when pairs are on separate lines when both pairs are explicit pairs - is expected to be same line s(:pair, + is expected not to be same line s(:pair, s(:sym, :b), s(:int, 2)) + when last pair is a keyword splat + is expected not to be same line s(:kwsplat, + s(:send, nil, :foo)) when a multiline pair shares the same line when both pairs are explicit pairs is expected to be same line s(:pair, - s(:sym, :b), - s(:int, 2)) - is expected to be same line s(:pair, s(:sym, :a), s(:begin)) + is expected to be same line s(:pair, + s(:sym, :b), + s(:int, 2)) when last pair is a keyword splat is expected to be same line s(:pair, s(:sym, :a), s(:begin)) is expected to be same line s(:kwsplat, s(:send, nil, :foo)) - #inverse_delimiter - when using a hash rocket delimiter - is expected to eq ":" - is expected to eq ": " - when using a colon delimiter - is expected to eq " => " - is expected to eq "=>" -RuboCop::AST::WhenNode - #then? - without a then keyword - is expected not to be then - with a then keyword - is expected to be then - #conditions - with a multiple conditions - is expected to all be literal - is expected to eq 3 - with a single condition - is expected to all be literal - is expected to eq 1 - #branch_index - is expected to eq 2 - is expected to eq 0 - is expected to eq 1 - #each_condition - when not passed a block - is expected to be a kind of Enumerator - when passed a block - yields all the conditions - .new - is expected to be a kind of RuboCop::AST::WhenNode - #body - with a then keyword - is expected to be sym type - without a then keyword - is expected to be array type - -RuboCop::AST::ArgNode - #name - with argument forwarding - with Ruby >= 2.7 - is expected to be nil - with Ruby >= 3.0 - is expected to be nil - with a nameless double splatted argument - is expected to be nil - with a regular argument - is expected to eq :x - with an optional argument - is expected to eq :x - with a block argument - is expected to eq :x - with a block - is expected to eq :x - with a nameless splatted argument - is expected to be nil - with an optional keyword argument - is expected to eq :x - with a double splatted argument - is expected to eq :x - with a splatted argument - is expected to eq :x - with a keyword argument - is expected to eq :x - with a shadow argument - is expected to eq :x - #default_value - with a splatted argument - is expected to be nil - with a block argument - is expected to be nil - with an optional argument - is expected to eq s(:int, 42) - with a shadow argument - is expected to be nil - with an optional keyword argument - is expected to eq s(:int, 42) - with a block - is expected to be nil - with argument forwarding - with Ruby >= 2.7 - is expected to be nil - with Ruby >= 3.0 - is expected to be nil - with a regular argument - is expected to be nil - with a double splatted argument - is expected to be nil - #default? - with an optional argument - is expected to equal true - with a double splatted argument - is expected to equal false - with a shadow argument - is expected to equal false - with a splatted argument - is expected to equal false - with argument forwarding - with Ruby >= 2.7 - is expected to equal false - with Ruby >= 3.0 - is expected to equal false - with a block - is expected to equal false - with a block argument - is expected to equal false - with a regular argument - is expected to equal false - with an optional keyword argument - is expected to equal true +RuboCop::AST::Procarg0Node .new - with a lambda literal - is expected to be a kind of RuboCop::AST::ArgNode - with a splatted argument - is expected to be a kind of RuboCop::AST::ArgNode - with argument forwarding - with Ruby >= 2.7 - is expected to be a kind of RuboCop::AST::ArgNode - with Ruby >= 3.0 - is expected to be a kind of RuboCop::AST::ArgNode - with an optional argument - is expected to be a kind of RuboCop::AST::ArgNode - with a method definition - is expected to be a kind of RuboCop::AST::ArgNode with a block is expected to be a kind of RuboCop::AST::ArgNode - with a keyword argument - is expected to be a kind of RuboCop::AST::ArgNode - with a block argument - is expected to be a kind of RuboCop::AST::ArgNode - with a double splatted argument - is expected to be a kind of RuboCop::AST::ArgNode - with a shadow argument - is expected to be a kind of RuboCop::AST::ArgNode - with an optional keyword argument - is expected to be a kind of RuboCop::AST::ArgNode + #name + is expected to eq :x -RuboCop::AST::ForNode - #keyword - is expected to eq "for" - #variable - is expected to be lvasgn type - #collection - is expected to be sym type - #body - is expected to be sym type - #void_context? - with a do keyword - is expected to be void context - without a do keyword - is expected to be void context +RuboCop::AST::InPatternNode + when using Ruby 2.7 or newer + #pattern + with a value pattern + is expected to be int type + with an as pattern + is expected to be match as type + with a pin operator + is expected to be pin type + with an alternative pattern + is expected to be match alt type + with an array pattern + is expected to be array pattern type + with a variable pattern + is expected to be match var type + with a hash pattern + is expected to be hash pattern type + #branch_index + is expected to eq 2 + is expected to eq 1 + is expected to eq 0 + .new + is expected to be a kind of RuboCop::AST::InPatternNode + #body + without a then keyword + is expected to be array type + with a then keyword + is expected to be sym type + #then? + with a then keyword + is expected to be then + without a then keyword + is expected not to be then + +Changelog + parses correctly + merges correctly + Changelog::Entry + generates correct content + +RuboCop::AST::UntilNode + #loop_keyword? + with a modifier until + is expected to be loop keyword + with a statement until + is expected to be loop keyword #do? without a do keyword is expected not to be do with a do keyword is expected to be do #post_condition_loop? - is expected not to be post condition loop + with a modifier until + is expected to be post condition loop + with a statement until + is expected not to be post condition loop + #keyword + is expected to eq "until" .new - is expected to be a kind of RuboCop::AST::ForNode - #loop_keyword? - is expected to be loop keyword - -RuboCop::AST::NodePattern::Sets - is expected to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC" - is expected to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC" - creates a constant with the right value - is expected not to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC_2" + with a modifier until + is expected to be a kind of RuboCop::AST::UntilNode + with a statement until + is expected to be a kind of RuboCop::AST::UntilNode + #inverse_keyword + is expected to eq "while" -RuboCop::AST::SendNode - .new - with a regular method send - is expected to be a kind of RuboCop::AST::SendNode - with a safe navigation method send - is expected to be a kind of RuboCop::AST::SendNode - #splat_argument? - with a splat argument - is expected to be splat argument - with regular arguments - is expected not to be splat argument - with mixed arguments - is expected to be splat argument - with no arguments - is expected not to be splat argument - #block_literal? - with a block argument - is expected not to be block literal - with no block - is expected not to be block literal - with Ruby >= 2.7 - with a numblock literal - is expected to be block literal - with a block literal - is expected to be block literal +RuboCop::AST::DefNode + #receiver + with a class method definition + is expected to be self type + with an instance method definition + is expected to be nil + with a singleton method definition + is expected to be const type + #method_name + with an operator method + is expected to eq :== + with a setter method + is expected to eq :foo= + with a plain method + is expected to eq :foo + with a unary method + is expected to eq :-@ #const_receiver? - with a non-constant receiver - is expected not to be const receiver - with a self receiver + with a class method definition is expected not to be const receiver - with a constant receiver + with a singleton method definition is expected to be const receiver - #arguments - with a single literal argument - is expected to eq 1 - with multiple literal arguments - is expected to eq 2 + with an instance method definition + is expected not to be const receiver + #predicate_method? + with a regular method + is expected not to be predicate method + with a predicate method + is expected to be predicate method + with a bang method + is expected not to be predicate method + #block_argument? + with regular arguments + is expected not to be block argument + with mixed arguments + is expected to be block argument + with a block argument + is expected to be block argument + with no arguments + is expected not to be block argument + #arguments? + with multiple regular arguments + is expected to be arguments + with a single regular argument + is expected to be arguments + with no arguments + is expected not to be arguments + with a single rest argument + is expected to be arguments + with a single keyword argument + is expected to be arguments with multiple mixed arguments - is expected to eq 2 + is expected to be arguments + #last_argument + with multiple regular arguments + is expected to be arg type + with a single rest argument + is expected to be restarg type + with multiple mixed arguments + is expected to be restarg type + with a single keyword argument + is expected to be kwoptarg type + with a single regular argument + is expected to be arg type with no arguments - is expected to be empty - with a single splat argument - is expected to eq 1 - #nonmutating_unary_operator_method? - with a nonmutating unary operator method - is expected to be nonmutating unary operator method + is expected to be nil + #rest_argument? + with a rest argument + is expected to be rest argument + with mixed arguments + is expected to be rest argument + with regular arguments + is expected not to be rest argument + with no arguments + is expected not to be rest argument + #void_context? + with a bracket assignment method + is expected to be void context + with a regular assignment method + is expected to be void context + with a comparison method + is expected not to be void context + with an initializer method + is expected to be void context with a regular method - is expected not to be nonmutating unary operator method - #nonmutating_binary_operator_method? - with a mutating binary operator method - is expected not to be nonmutating binary operator method + is expected not to be void context + #body + with a single expression body + is expected to be send type + with a multi-expression body + is expected to be begin type + with no body + is expected to be nil + #bang_method? with a regular method - is expected not to be nonmutating binary operator method - with a nonmutating binary operator method - is expected to be nonmutating binary operator method - #enumerable_method? + is expected not to be bang method + with a predicate method + is expected not to be bang method + with a bang method + is expected to be bang method + #endless? + with standard method definition + is expected not to be endless + with endless method definition + is expected to be endless + #assignment_method? + with an assignment method + is expected to be assignment method with a regular method - is expected not to be enumerable method - with an enumerable method - is expected to be enumerable method - #lambda? - with a non-lambda method - is expected not to be lambda - with a lambda method - is expected to be lambda - with a method named lambda in a class - is expected not to be lambda - with a stabby lambda method - is expected to be lambda - #last_argument - with a single literal argument - is expected to be sym type + is expected not to be assignment method + with a bracket assignment method + is expected to be assignment method + with a comparison method + is expected not to be assignment method + .new + with a defs node + is expected to be a kind of RuboCop::AST::DefNode + with a def node + is expected to be a kind of RuboCop::AST::DefNode + #operator_method? + with a regular method + is expected not to be operator method + with a setter method + is expected not to be operator method + with a binary operator method + is expected to be operator method + with a unary operator method + is expected to be operator method + #comparison_method? + with a comparison method + is expected to be comparison method + with a regular method + is expected not to be comparison method + #camel_case_method? + with a camel case method + is expected to be camel case method + with a regular method + is expected not to be camel case method + #self_receiver? + with a singleton method definition + is expected not to be self receiver + with an instance method definition + is expected not to be self receiver + with a class method definition + is expected to be self receiver + #arguments + with no arguments + is expected to be empty + with argument forwarding + is expected to eq 1 with multiple mixed arguments - is expected to be splat type + is expected to eq 2 + with a single regular argument + is expected to eq 1 + with a single rest argument + is expected to eq 1 + with multiple regular arguments + is expected to eq 2 + #first_argument + with a single regular argument + is expected to be arg type + with multiple regular arguments + is expected to be arg type with no arguments is expected to be nil - with multiple literal arguments - is expected to be sym type - with a single splat argument - is expected to be splat type + with a single rest argument + is expected to be restarg type + with multiple mixed arguments + is expected to be arg type + with a single keyword argument + is expected to be kwoptarg type #method? when message matches when argument is a symbol @@ -1612,1738 +3447,1540 @@ when argument is a string is expected to be method "bar" when message does not match - when argument is a string - is expected not to be method "foo" when argument is a symbol is expected not to be method :foo - #def_modifier - with a block containing a method definition + when argument is a string + is expected not to be method "foo" + when using Ruby 2.7 or newer + #argument_forwarding? + is expected to be argument forwarding + +RuboCop::AST::KeywordSplatNode + #operator + is expected to eq "**" + #same_line? + when pairs are on separate lines + is expected not to be same line s(:kwsplat, + s(:send, nil, :foo)) + when both pairs are on the same line + is expected to be same line s(:kwsplat, + s(:send, nil, :foo)) + when a multiline pair shares the same line + is expected to be same line s(:kwsplat, + s(:send, nil, :foo)) + is expected to be same line s(:pair, + s(:sym, :a), + s(:begin)) + #key + is expected to eq s(:kwsplat, + s(:send, nil, :foo)) + #key_delta + with alignment set to :right + when using hash rocket delimiters + when keyword splat is aligned + is expected to eq 0 + when keyword splat is on the same line + is expected to eq 0 + when keyword splat is behind + is expected to eq 0 + when keyword splat is ahead + is expected to eq 0 + when using colon delimiters + when keyword splat is behind + is expected to eq 0 + when keyword splat is on the same line + is expected to eq 0 + when keyword splat is ahead + is expected to eq 0 + when keyword splat is aligned + is expected to eq 0 + with alignment set to :left + when using hash rocket delimiters + when keyword splat is on the same line + is expected to eq 0 + when keyword splat is ahead + is expected to eq 2 + when keyword splat is aligned + is expected to eq 0 + when keyword splat is behind + is expected to eq -2 + when using colon delimiters + when keyword splat is ahead + is expected to eq 2 + when keyword splat is aligned + is expected to eq 0 + when keyword splat is behind + is expected to eq -2 + when keyword splat is on the same line + is expected to eq 0 + #colon? + is expected not to be colon + #value + is expected to eq s(:kwsplat, + s(:send, nil, :foo)) + .new + is expected to be a kind of RuboCop::AST::KeywordSplatNode + #hash_rocket? + is expected not to be hash rocket + #value_delta + when using hash rocket delimiters + when keyword splat is left aligned + is expected to eq 0 + when keyword splat is ahead + is expected to eq 0 + when keyword splat is behind + is expected to eq 0 + when keyword splat is on the same line + is expected to eq 0 + when using colon delimiters + when keyword splat is behind + is expected to eq 0 + when keyword splat is on the same line + is expected to eq 0 + when keyword splat is ahead + is expected to eq 0 + when keyword splat is left aligned + is expected to eq 0 + +RuboCop::AST::SendNode + #access_modifier? + when node is a bare `module_function` + is expected to be access modifier + when node is a non-bare `module_function` + is expected to be access modifier + when node is not an access modifier + is expected not to be bare access modifier + #nonmutating_unary_operator_method? + with a regular method + is expected not to be nonmutating unary operator method + with a nonmutating unary operator method + is expected to be nonmutating unary operator method + #nonmutating_array_method? + with a mutating Array method + is expected not to be nonmutating array method + with a nonmutating Array method + is expected to be nonmutating array method + with a regular method + is expected not to be nonmutating array method + #block_node + with a block argument is expected to be nil - with several prefixed def modifiers - is expected to eq :qux - with call with no argument + with Ruby >= 2.7 + with a numblock literal + is expected to be numblock type + with no block is expected to be nil - with a prefixed def modifier - is expected to eq :bar - #nonmutating_hash_method? - with a mutating Hash method - is expected not to be nonmutating hash method + with a block literal + is expected to be block type + #nonmutating_binary_operator_method? + with a nonmutating binary operator method + is expected to be nonmutating binary operator method + with a mutating binary operator method + is expected not to be nonmutating binary operator method with a regular method - is expected not to be nonmutating hash method - with a nonmutating Hash method - is expected to be nonmutating hash method + is expected not to be nonmutating binary operator method + #parenthesized? + with no arguments + when not using parentheses + is expected not to be parenthesized + when using parentheses + is expected to be parenthesized + with arguments + when not using parentheses + is expected not to be parenthesized + when using parentheses + is expected to be parenthesized #receiver - with a variable receiver - is expected to be send type with no receiver is expected to be nil + with a variable receiver + is expected to be send type with a literal receiver is expected to be str type + #prefix_bang? + with a bang method + is expected to be prefix bang + with a non-negated method + is expected not to be prefix bang + with keyword `not` + is expected not to be prefix bang + #def_modifier? + with several prefixed def modifiers + is expected to be def modifier + with a prefixed def modifier + is expected to be def modifier + with a block containing a method definition + is expected not to be def modifier #non_bare_access_modifier? - when node is not an access modifier - is expected not to be non bare access modifier when node does not have an argument is expected not to be non bare access modifier when node is a non-bare `module_function` is expected to be non bare access modifier - #bare_access_modifier? - with Ruby >= 2.7 - when node is access modifier in numblock - is expected to be bare access modifier - when node is access modifier in block - is expected to be bare access modifier - when node has an argument - is expected not to be bare access modifier when node is not an access modifier - is expected not to be bare access modifier - when node is a bare `module_function` - is expected to be bare access modifier - #loop_keyword? - is expected not to be loop keyword - #predicate_method? - with a bang method - is expected not to be predicate method - with a predicate method - is expected to be predicate method - with a regular method - is expected not to be predicate method - #operator_method? - with a unary operator method - is expected to be operator method - with a setter method - is expected not to be operator method - with a binary operator method - is expected to be operator method - with a regular method - is expected not to be operator method - #nonmutating_array_method? - with a nonmutating Array method - is expected to be nonmutating array method - with a mutating Array method - is expected not to be nonmutating array method + is expected not to be non bare access modifier + #camel_case_method? + with a camel case method + is expected to be camel case method with a regular method - is expected not to be nonmutating array method + is expected not to be camel case method + #const_receiver? + with a constant receiver + is expected to be const receiver + with a non-constant receiver + is expected not to be const receiver + with a self receiver + is expected not to be const receiver + #arguments + with no arguments + is expected to be empty + with a single literal argument + is expected to eq 1 + with a single splat argument + is expected to eq 1 + with multiple literal arguments + is expected to eq 2 + with multiple mixed arguments + is expected to eq 2 + #block_argument? + with regular arguments + is expected not to be block argument + with a block argument + is expected to be block argument + with mixed arguments + is expected to be block argument + with no arguments + is expected not to be block argument + #lambda? + with a stabby lambda method + is expected to be lambda + with a method named lambda in a class + is expected not to be lambda + with a lambda method + is expected to be lambda + with a non-lambda method + is expected not to be lambda #nonmutating_operator_method? - with a nonmutating binary operator method - is expected to be nonmutating operator method - with a regular method - is expected not to be nonmutating operator method with a mutating binary operator method is expected not to be nonmutating operator method with a nonmutating unary operator method is expected to be nonmutating operator method - #comparison_method? - with a comparison method - is expected to be comparison method + with a nonmutating binary operator method + is expected to be nonmutating operator method with a regular method - is expected not to be comparison method - with a negation method - is expected not to be comparison method - #prefix_bang? - with keyword `not` - is expected not to be prefix bang - with a non-negated method - is expected not to be prefix bang - with a bang method - is expected to be prefix bang - #method_name - with an implicit call method - is expected to eq :call - with a plain method - is expected to eq :bar + is expected not to be nonmutating operator method + #setter_method? with an operator method - is expected to eq :== + is expected not to be setter method with a setter method - is expected to eq :bar= - #def_modifier? - with a block containing a method definition - is expected not to be def modifier - with a prefixed def modifier - is expected to be def modifier - with several prefixed def modifiers - is expected to be def modifier + is expected to be setter method + with an indexed setter method + is expected to be setter method + with a regular method + is expected not to be setter method + #nonmutating_hash_method? + with a mutating Hash method + is expected not to be nonmutating hash method + with a nonmutating Hash method + is expected to be nonmutating hash method + with a regular method + is expected not to be nonmutating hash method + #self_receiver? + with a non-self receiver + is expected not to be self receiver + with a self receiver + is expected to be self receiver + with an implicit receiver + is expected not to be self receiver + #splat_argument? + with a splat argument + is expected to be splat argument + with regular arguments + is expected not to be splat argument + with no arguments + is expected not to be splat argument + with mixed arguments + is expected to be splat argument #first_argument + with multiple literal arguments + is expected to be sym type with a single splat argument is expected to be splat type - with no arguments - is expected to be nil with multiple mixed arguments is expected to be sym type - with multiple literal arguments - is expected to be sym type with a single literal argument is expected to be sym type - #bang_method? - with a predicate method - is expected not to be bang method + with no arguments + is expected to be nil + #comparison_method? with a regular method - is expected not to be bang method - with a bang method - is expected to be bang method - #binary_operation?? - with a regular method call - is expected not to be binary operation - with an implicit call method - is expected not to be binary operation - with a binary operation - is expected to be binary operation - with a unary operation - is expected not to be binary operation - #unary_operation? - with an implicit call method - is expected not to be unary operation - with a regular method call - is expected not to be unary operation - with a binary operation - is expected not to be unary operation - with a unary operation - is expected to be unary operation - #attribute_accessor? - with an accessor - returns the accessor method and Array] - with a call without arguments - is expected to be nil + is expected not to be comparison method + with a comparison method + is expected to be comparison method + with a negation method + is expected not to be comparison method #negation_method? - with a non-negated method - is expected not to be negation method with prefix bang is expected to be negation method with suffix `not` is expected not to be negation method + with a non-negated method + is expected not to be negation method with prefix `not` is expected to be negation method - #nonmutating_string_method? - with a regular method - is expected not to be nonmutating string method - with a mutating String method - is expected not to be nonmutating string method - with a nonmutating String method - is expected to be nonmutating string method + #lambda_literal? + with a non-lambda method + is expected not to be lambda + with a lambda method + is expected not to be lambda literal + with a stabby lambda + is expected to be lambda literal + with `a.() {}` style method + is expected not to be lambda + #loop_keyword? + is expected not to be loop keyword #arguments? - with a single splat argument + with a single literal argument is expected to be arguments with multiple literal arguments is expected to be arguments - with a single literal argument - is expected to be arguments - with multiple mixed arguments + with a single splat argument is expected to be arguments with no arguments is expected not to be arguments + with multiple mixed arguments + is expected to be arguments + #implicit_call? + with a regular method + is expected not to be implicit call + with an implicit call method + is expected to be implicit call + with an explicit call method + is expected not to be implicit call + #method? + when message matches + when argument is a symbol + is expected to be method :bar + when argument is a string + is expected to be method "bar" + when message does not match + when argument is a symbol + is expected not to be method :foo + when argument is a string + is expected not to be method "foo" + #binary_operation?? + with a unary operation + is expected not to be binary operation + with a regular method call + is expected not to be binary operation + with a binary operation + is expected to be binary operation + with an implicit call method + is expected not to be binary operation + #bare_access_modifier? + when node is a bare `module_function` + is expected to be bare access modifier + when node is not an access modifier + is expected not to be bare access modifier + when node has an argument + is expected not to be bare access modifier + with Ruby >= 2.7 + when node is access modifier in numblock + is expected to be bare access modifier + when node is access modifier in block + is expected to be bare access modifier + #prefix_not? + with a non-negated method + is expected not to be prefix not + with keyword `not` + is expected to be prefix not + with a bang method + is expected not to be prefix not + #assignment_method? + with an assignment method + is expected to be assignment method + with a bracket assignment method + is expected to be assignment method + with a comparison method + is expected not to be assignment method + with a regular method + is expected not to be assignment method + #method_name + with an implicit call method + is expected to eq :call + with an operator method + is expected to eq :== + with a plain method + is expected to eq :bar + with a setter method + is expected to eq :bar= + #post_condition_loop? + is expected not to be post condition loop + #double_colon? + with a dot + is expected not to be double colon + with a double colon + is expected to be double colon + with a unary method + is expected not to be double colon + without a dot + is expected not to be double colon + #attribute_accessor? + with an accessor + returns the accessor method and Array] + with a call without arguments + is expected to be nil + #predicate_method? + with a bang method + is expected not to be predicate method + with a predicate method + is expected to be predicate method + with a regular method + is expected not to be predicate method + #arithmetic_operation? + with a regular method call + is expected not to be arithmetic operation + with a binary arithmetic operation + is expected to be arithmetic operation + with a unary numeric operation + is expected not to be arithmetic operation #macro? without a receiver - when parent is a struct constructor + when the condition of an if + is expected not to be macro + when parent is a module is expected to be macro when parent is a class constructor is expected to be macro when in an if is expected to be macro - when parent is a block not in a macro scope - is expected not to be macro - when parent is a block in a macro scope + when parent is a class + is expected to be macro + when parent is a singleton class is expected to be macro - when parent is a method definition - is expected not to be macro when parent is a begin without a parent is expected to be macro + with Ruby >= 2.7 + when parent is a numblock in a macro scope + is expected to be macro without a parent is expected to be macro - when parent is a singleton class - is expected to be macro - when parent is a keyword begin inside of an class + when parent is a block in a macro scope is expected to be macro - when parent is a module + when parent is a struct constructor is expected to be macro + when parent is a method definition + is expected not to be macro when in the global scope is expected to be macro - when parent is a class + when parent is a keyword begin inside of an class is expected to be macro - with Ruby >= 2.7 - when parent is a numblock in a macro scope - is expected to be macro - when the condition of an if + when parent is a block not in a macro scope is expected not to be macro with a receiver when parent is a module is expected not to be macro when parent is a class is expected not to be macro - #parenthesized? - with no arguments - when using parentheses - is expected to be parenthesized - when not using parentheses - is expected not to be parenthesized - with arguments - when using parentheses - is expected to be parenthesized - when not using parentheses - is expected not to be parenthesized - #setter_method? + #nonmutating_string_method? + with a nonmutating String method + is expected to be nonmutating string method + with a mutating String method + is expected not to be nonmutating string method with a regular method - is expected not to be setter method - with an operator method - is expected not to be setter method + is expected not to be nonmutating string method + #operator_method? with a setter method - is expected to be setter method - with an indexed setter method - is expected to be setter method - #arithmetic_operation? - with a unary numeric operation - is expected not to be arithmetic operation - with a regular method call - is expected not to be arithmetic operation - with a binary arithmetic operation - is expected to be arithmetic operation - #lambda_literal? - with a non-lambda method - is expected not to be lambda - with a lambda method - is expected not to be lambda literal - with `a.() {}` style method - is expected not to be lambda - with a stabby lambda - is expected to be lambda literal + is expected not to be operator method + with a regular method + is expected not to be operator method + with a binary operator method + is expected to be operator method + with a unary operator method + is expected to be operator method + #bang_method? + with a predicate method + is expected not to be bang method + with a regular method + is expected not to be bang method + with a bang method + is expected to be bang method + #enumerable_method? + with a regular method + is expected not to be enumerable method + with an enumerable method + is expected to be enumerable method + .new + with a safe navigation method send + is expected to be a kind of RuboCop::AST::SendNode + with a regular method send + is expected to be a kind of RuboCop::AST::SendNode + #def_modifier + with a block containing a method definition + is expected to be nil + with call with no argument + is expected to be nil + with several prefixed def modifiers + is expected to eq :qux + with a prefixed def modifier + is expected to eq :bar #dot? with a dot is expected to be dot - with a double colon - is expected not to be dot without a dot is expected not to be dot with a unary method is expected not to be dot - #self_receiver? - with a self receiver - is expected to be self receiver - with a non-self receiver - is expected not to be self receiver - with an implicit receiver - is expected not to be self receiver - #block_node - with no block - is expected to be nil - with Ruby >= 2.7 - with a numblock literal - is expected to be numblock type - with a block literal - is expected to be block type - with a block argument - is expected to be nil - #implicit_call? - with an implicit call method - is expected to be implicit call - with an explicit call method - is expected not to be implicit call - with a regular method - is expected not to be implicit call - #block_argument? - with mixed arguments - is expected to be block argument - with regular arguments - is expected not to be block argument - with a block argument - is expected to be block argument - with no arguments - is expected not to be block argument - #assignment_method? - with a regular method - is expected not to be assignment method - with an assignment method - is expected to be assignment method - with a bracket assignment method - is expected to be assignment method - with a comparison method - is expected not to be assignment method - #access_modifier? - when node is not an access modifier - is expected not to be bare access modifier - when node is a non-bare `module_function` - is expected to be access modifier - when node is a bare `module_function` - is expected to be access modifier - #prefix_not? - with a bang method - is expected not to be prefix not - with a non-negated method - is expected not to be prefix not - with keyword `not` - is expected to be prefix not - #post_condition_loop? - is expected not to be post condition loop - #double_colon? - with a dot - is expected not to be double colon - with a unary method - is expected not to be double colon - without a dot - is expected not to be double colon with a double colon - is expected to be double colon - #camel_case_method? - with a camel case method - is expected to be camel case method - with a regular method - is expected not to be camel case method + is expected not to be dot + #unary_operation? + with an implicit call method + is expected not to be unary operation + with a regular method call + is expected not to be unary operation + with a unary operation + is expected to be unary operation + with a binary operation + is expected not to be unary operation #command? when argument is a string - with an explicit receiver - is expected not to be command "bar" with an implicit receiver is expected to be command "bar" + with an explicit receiver + is expected not to be command "bar" when argument is a symbol - with an implicit receiver - is expected to be command :bar with an explicit receiver is expected not to be command :bar + with an implicit receiver + is expected to be command :bar + #last_argument + with a single splat argument + is expected to be splat type + with multiple literal arguments + is expected to be sym type + with a single literal argument + is expected to be sym type + with no arguments + is expected to be nil + with multiple mixed arguments + is expected to be splat type + #block_literal? + with a block argument + is expected not to be block literal + with Ruby >= 2.7 + with a numblock literal + is expected to be block literal + with no block + is expected not to be block literal + with a block literal + is expected to be block literal -RuboCop::AST::UntilNode - .new - with a statement until - is expected to be a kind of RuboCop::AST::UntilNode - with a modifier until - is expected to be a kind of RuboCop::AST::UntilNode - #do? - without a do keyword - is expected not to be do - with a do keyword - is expected to be do - #inverse_keyword - is expected to eq "while" - #loop_keyword? - with a modifier until - is expected to be loop keyword - with a statement until - is expected to be loop keyword - #post_condition_loop? - with a modifier until - is expected to be post condition loop - with a statement until - is expected not to be post condition loop - #keyword - is expected to eq "until" +RuboCop::AST::BreakNode + behaves like wrapped arguments node + .new + with arguments + is expected to be a kind of RuboCop::AST::BreakNode + without arguments + is expected to be a kind of RuboCop::AST::BreakNode + #arguments + with a single argument + is expected to eq 1 + with no arguments + is expected to be empty + with a single splat argument + is expected to eq 1 + with a single argument and braces + is expected to eq 1 + with multiple literal arguments + is expected to eq 2 + with no arguments and braces + is expected to be empty -RuboCop::AST::AliasNode - #new_identifier - is expected to eq :foo - is expected to be sym type +Set#=== + tests for inclusion + +RuboCop::AST::ConstNode + #namespace + is expected to eq "::Foo::Bar" + #short_name + is expected to eq :BAZ + #absolute? + is expected to be absolute + with a constant not starting with :: + is expected not to be absolute + with a non-namespaced constant + is expected not to be absolute + #each_path + yields all parts of the namespace + #module_name? + is expected not to be module name + with a constant with a lowercase letter + is expected to be module name + #relative? + with a non-namespaced constant + is expected to be relative + +RuboCop::AST::IntNode + #sign? + explicit positive int + is expected to be sign + explicit negative int + is expected to be sign + #value + is expected to eq 10 .new - is expected to be a kind of RuboCop::AST::AliasNode - #old_identifier - is expected to be sym type - is expected to eq :bar + is expected to be a kind of RuboCop::AST::IntNode -RuboCop::AST::SelfClassNode - #identifier - is expected to be self type +RuboCop::AST::ModuleNode .new - is expected to be a kind of RuboCop::AST::SelfClassNode + is expected to be a kind of RuboCop::AST::ModuleNode #body - with a single expression body - is expected to be send type with a multi-expression body is expected to be begin type + with a single expression body + is expected to be send type with an empty body is expected to be nil + #identifier + is expected to be const type -RuboCop::AST::AndNode - #operator - with a semantic and node - is expected to eq "and" - with a logical and node - is expected to eq "&&" +RuboCop::AST::OrNode .new - with a semantic and node - is expected to be a kind of RuboCop::AST::AndNode - with a logical and node - is expected to be a kind of RuboCop::AST::AndNode + with a logical or node + is expected to be a kind of RuboCop::AST::OrNode + with a semantic or node + is expected to be a kind of RuboCop::AST::OrNode #logical_operator? - with a semantic and node + with a semantic or node is expected not to be logical operator - with a logical and node + with a logical or node is expected to be logical operator + #operator + with a logical or node + is expected to eq "||" + with a semantic or node + is expected to eq "or" + #alternate_operator + with a logical or node + is expected to eq "or" + with a semantic or node + is expected to eq "||" #rhs - with a semantic and node + with a logical or node is expected to be int type - with a logical and node + with a semantic or node is expected to be int type + #inverse_operator + with a logical or node + is expected to eq "&&" + with a semantic or node + is expected to eq "and" #lhs - with a logical and node + with a semantic or node is expected to be sym type - with a semantic and node + with a logical or node is expected to be sym type - #inverse_operator - with a semantic and node - is expected to eq "or" - with a logical and node - is expected to eq "||" - #alternate_operator - with a logical and node - is expected to eq "and" - with a semantic and node - is expected to eq "&&" #semantic_operator? - with a logical and node + with a logical or node is expected not to be semantic operator - with a semantic and node + with a semantic or node is expected to be semantic operator -Set#=== - tests for inclusion +RuboCop::AST::SuperNode + #block_argument? + with no arguments + is expected not to be block argument + with a block argument + is expected to be block argument + with regular arguments + is expected not to be block argument + with mixed arguments + is expected to be block argument + #block_literal? + with no block + is expected not to be block literal + with a block argument + is expected not to be block literal + with a block literal + is expected to be block literal + #double_colon? + is expected not to be double colon + #last_argument + with a single literal argument + is expected to be sym type + with a single splat argument + is expected to be splat type + with multiple mixed arguments + is expected to be splat type + with no arguments + is expected to be nil + with multiple literal arguments + is expected to be sym type + #const_receiver? + is expected not to be const receiver + #command? + when argument is a string + is expected to be command "super" + when argument is a symbol + is expected to be command :super + #method? + when message matches + when argument is a symbol + is expected to be method :super + when argument is a string + is expected to be method "super" + when message does not match + when argument is a symbol + is expected not to be method :foo + when argument is a string + is expected not to be method "foo" + #first_argument + with a single splat argument + is expected to be splat type + with multiple mixed arguments + is expected to be sym type + with a single literal argument + is expected to be sym type + with no arguments + is expected to be nil + with multiple literal arguments + is expected to be sym type + #method_name + is expected to eq :super + #setter_method? + is expected not to be setter method + #bang_method? + is expected not to be bang method + #splat_argument? + with a splat argument + is expected to be splat argument + with mixed arguments + is expected to be splat argument + with no arguments + is expected not to be splat argument + with regular arguments + is expected not to be splat argument + .new + with a zsuper node + is expected to be a kind of RuboCop::AST::SuperNode + with a super node + is expected to be a kind of RuboCop::AST::SuperNode + #receiver + is expected to be nil + #macro? + is expected not to be macro + #self_receiver? + is expected not to be self receiver + #predicate_method? + is expected not to be predicate method + #dot? + is expected not to be dot + #parenthesized? + with arguments + when using parentheses + is expected to be parenthesized + when not using parentheses + is expected not to be parenthesized + with no arguments + when not using parentheses + is expected not to be parenthesized + when using parentheses + is expected to be parenthesized + #arguments? + with multiple literal arguments + is expected to be arguments + with a single literal argument + is expected to be arguments + with a single splat argument + is expected to be arguments + with no arguments + is expected not to be arguments + with multiple mixed arguments + is expected to be arguments + #assignment_method? + is expected not to be assignment method + #comparison_method? + is expected not to be comparison method + #operator_method? + is expected not to be operator method + #arguments + with a single literal argument + is expected to eq 1 + with no arguments + is expected to be empty + with multiple mixed arguments + is expected to eq 2 + with multiple literal arguments + is expected to eq 2 + with a single splat argument + is expected to eq 1 + #implicit_call? + is expected not to be implicit call + #block_node + with no block + is expected to be nil + with a block literal + is expected to be block type + with a block argument + is expected to be nil + #camel_case_method? + is expected not to be camel case method RuboCop::AST::CaseNode - #branches - when there is an else - returns all the bodies - with an empty else - returns all the bodies - when compared to an IfNode - returns the same - when there is no else keyword - returns only then when bodies - .new - is expected to be a kind of RuboCop::AST::CaseNode #else_branch #else? - without an else statement + with an empty else statement is expected to be nil with an else statement is expected to be sym type - with an empty else statement + without an else statement is expected to be nil #else? - without an else statement - is expected not to be else with an else statement is expected to be else + without an else statement + is expected not to be else #each_when - when not passed a block - is expected to be a kind of Enumerator when passed a block yields all the conditions + when not passed a block + is expected to be a kind of Enumerator + #branches + when there is no else keyword + returns only then when bodies + when there is an else + returns all the bodies + with an empty else + returns all the bodies + when compared to an IfNode + returns the same #keyword is expected to eq "case" #when_branches is expected to all be when type is expected to eq 3 - -RuboCop::AST::ModuleNode - #body - with an empty body - is expected to be nil - with a multi-expression body - is expected to be begin type - with a single expression body - is expected to be send type - #identifier - is expected to be const type - .new - is expected to be a kind of RuboCop::AST::ModuleNode - -RuboCop::AST::ArrayNode - #bracketed? - unbracketed - is expected to be nil - with square brackets - is expected to be bracketed - with a percent literal - is expected to be bracketed - #each_value - with block - is expected to eq ["(int 1)", "(int 2)", "(int 3)"] - is expected to be a kind of RuboCop::AST::ArrayNode - without block - is expected to be a kind of Enumerator - #percent_literal? - with a symbol percent literal - is expected to be percent literal - is expected to be percent literal :symbol - is expected not to be percent literal :string - with a string percent literal - is expected to be percent literal - is expected to be percent literal :string - is expected not to be percent literal :symbol - with square brackets - is expected not to be percent literal :string - is expected not to be percent literal - is expected not to be percent literal :symbol - #square_brackets? - with a percent literal - is expected not to be square brackets - with square brackets - is expected to be square brackets - #values - with an empty array - is expected to be empty - with an array of variables - is expected to eq 2 - is expected to all be send type - with an array of literals - is expected to all be literal - is expected to eq 3 - .new - is expected to be a kind of RuboCop::AST::ArrayNode - -RuboCop::AST::RegexpNode - #multiline_mode? - with other options - is expected not to be multiline mode - with only m option - is expected to be multiline mode - with no options - is expected not to be multiline mode - with m and other options - is expected to be multiline mode - #content - with an empty regexp with option - is expected to eq "" - with an empty regexp - is expected to eq "" - with a multi-line regexp with option - is expected to eq "\n.+\n" - with a regexp with option - is expected to eq ".+" - with a multi-line regexp without option - is expected to eq "\n.+\n" - with a regexp without option - is expected to eq ".+" - #interpolation? - with no interpolation returns false - is expected not to be interpolation - with regexp quote - is expected to be interpolation - with direct variable interpoation - is expected to be interpolation - #no_encoding? - with no options - is expected not to be no encoding - with n and other options - is expected to be no encoding - with only n option - is expected to be no encoding - with other options - is expected not to be no encoding - #percent_r_literal? - with /-delimiters - is expected not to be percent r literal - with %r/-delimiters - is expected to be percent r literal - with %r<-delimiters - is expected to be percent r literal - with %r{-delimiters - is expected to be percent r literal - with multi-line %r{-delimiters - is expected to be percent r literal - #delimiters - with %r/-delimiters - is expected to eq ["/", "/"] - with %r{-delimiters - is expected to eq ["{", "}"] - with multi-line %r{-delimiters - is expected to eq ["{", "}"] - with %r<-delimiters - is expected to eq ["<", ">"] - with /-delimiters - is expected to eq ["/", "/"] - #fixed_encoding? - with u and other options - is expected to be fixed encoding - with only u option - is expected to be fixed encoding - with other options - is expected not to be fixed encoding - with no options - is expected not to be fixed encoding - #regopt - with an empty regexp - is expected to be empty - is expected to be regopt type - with an empty regexp with option - is expected to eq [:i, :x] - is expected to be regopt type - with a multi-line regexp without option - is expected to be regopt type - is expected to be empty - with a regexp without option - is expected to be regopt type - is expected to be empty - with a multi-line regexp with option - is expected to be regopt type - is expected to eq [:i, :m, :x] - with a regexp with option - is expected to eq [:i, :m, :x] - is expected to be regopt type - .new - is expected to be a kind of RuboCop::AST::RegexpNode - #ignore_case? - with i and other options - is expected to be ignore case - with other options - is expected not to be ignore case - with only i option - is expected to be ignore case - with no options - is expected not to be ignore case - #to_regexp - with a regexp with an "n" option - is expected to eq "/abc/n" - with a multi-line regexp with option - is expected to eq / -.+ -/ix - with a regexp with an "o" option - is expected to eq "/abc/i" - with a regexp with an "u" option - is expected to eq "/abc/" - with a regexp with option - is expected to eq /.+/mix - with an empty regexp - is expected to eq // - with a regexp without option - is expected to eq /.+/ - with an empty regexp with option - is expected to eq //ix - with a multi-line regexp without option - is expected to eq / -.+ -/ - #delimiter? - with %r/-delimiters - is expected not to be delimiter "%" - is expected not to be delimiter "}" - is expected not to be delimiter "{" - is expected not to be delimiter "%r/" - is expected to be delimiter "/" - is expected not to be delimiter "%r" - is expected not to be delimiter "r" - with %r<-delimiters - is expected not to be delimiter "/" - is expected not to be delimiter "}" - is expected not to be delimiter "r" - is expected not to be delimiter "{" - is expected not to be delimiter "%" - is expected not to be delimiter "%r<" - is expected not to be delimiter "%r/" - is expected not to be delimiter "%r" - is expected to be delimiter "<" - is expected to be delimiter ">" - is expected not to be delimiter "%r{" - with %r{-delimiters - is expected not to be delimiter "%r{" - is expected not to be delimiter "/" - is expected not to be delimiter "%r/" - is expected not to be delimiter "%r" - is expected not to be delimiter "r" - is expected not to be delimiter "%" - is expected to be delimiter "{" - is expected to be delimiter "}" - with multi-line %r{-delimiters - is expected not to be delimiter "/" - is expected to be delimiter "}" - is expected not to be delimiter "%r/" - is expected not to be delimiter "%" - is expected not to be delimiter "r" - is expected to be delimiter "{" - is expected not to be delimiter "%r" - is expected not to be delimiter "%r{" - with /-delimiters - is expected to be delimiter "/" - is expected not to be delimiter "{" - #extended? - with x and other options - is expected to be extended - with only x option - is expected to be extended - with other options - is expected not to be extended - with no options - is expected not to be extended - #options - with an empty regexp - is expected to eq 0 - with a regexp with "o" option - is expected to eq 0 - with a regexp without option - is expected to eq 0 - with a regexp with multiple options - is expected to eq 3 - with a regexp with single option - is expected to eq 1 - #slash_literal? - with %r<-delimiters - is expected not to be slash literal - with multi-line %r{-delimiters - is expected not to be slash literal - with %r{-delimiters - is expected not to be slash literal - with /-delimiters - is expected to be slash literal - with %r/-delimiters - is expected not to be slash literal - #single_interpolation? - with other options - is expected not to be single interpolation - with no options - is expected not to be single interpolation - with o and other options - is expected to be single interpolation - with only o option - is expected to be single interpolation - -RuboCop::AST::Token - #space_before - returns nil when there is not a space before token - returns nil when it is on the first line - returns truthy MatchData when there is a space before token - #begin_pos - returns index of first char in token range of entire source - #column - returns index of first char in token range on that line - #line - returns line of token - type predicates - #comma? - returns false for non comma tokens - returns true for comma tokens - #dot? - returns true for dot tokens - returns false for non dot tokens - #left_array_bracket? - returns true for left_array_bracket tokens - returns false for non left_array_bracket tokens - #regexp_dots? - returns true for regexp tokens - returns false for non comma tokens - #left_brace? - returns true for right_bracket tokens - returns false for non right_bracket tokens - #equals_sign? - returns true for equals sign tokens - returns false for non equals sign tokens - #right_bracket? - returns true for all right_bracket tokens - returns false for non right_bracket tokens - #left_ref_bracket? - returns false for non left_ref_bracket tokens - returns true for left_ref_bracket tokens - #semicolon? - returns true for semicolon tokens - returns false for non semicolon tokens - #comment? - returns false for non comment tokens - returns true for comment tokens - with braces & parens - #right_parens? - returns true for right parens tokens - returns false for non right parens tokens - #left_curly_brace? - returns false for non left block brace tokens - returns true for left block brace tokens - #right_curly_brace? - returns false for non right brace tokens - returns true for all right brace tokens - #left_parens? - returns true for left parens tokens - returns false for non left parens tokens - #left_brace? - returns false for non left hash brace tokens - returns true for left hash brace tokens - #rescue_modifier? - returns true for rescue modifier tokens - returns false for non rescue modifier tokens - #end? - returns false for non end tokens - returns true for end tokens - #left_bracket? - returns false for non left_bracket tokens - returns true for all left_bracket tokens - #new_line? - returns false for non new line tokens - returns true for new line tokens - #space_after - returns truthy MatchData when there is a space after token - returns nil when there is not a space after token - #to_s - returns string of token data - .from_parser_token - sets parser token's range to rubocop token's pos - sets parser token's type to rubocop token's type - returns a #to_s useful for debugging - sets parser token's text to rubocop token's text - #end_pos - returns index of last char in token range of entire source - -RuboCop::AST::CasgnNode - #namespace - when the parent is a `cbase` - is expected to eq s(:cbase) - when the parent is a `const` - is expected to eq s(:const, nil, :FOO) - when there is no parent - is expected to be nil - .new - with a `casgn` node - is expected to be a kind of RuboCop::AST::CasgnNode - #expression - is expected to eq s(:send, nil, :value) - #name - is expected to eq :VAR - -RuboCop::AST::RangeNode - .new - with an infinite range - is expected to be range type - is expected to be a kind of RuboCop::AST::RangeNode - with an exclusive range - is expected to be range type - is expected to be a kind of RuboCop::AST::RangeNode - with an inclusive range - is expected to be a kind of RuboCop::AST::RangeNode - is expected to be range type - with a beignless range - is expected to be a kind of RuboCop::AST::RangeNode - is expected to be range type - -RuboCop::AST::KeywordSplatNode - #operator - is expected to eq "**" - #same_line? - when pairs are on separate lines - is expected not to be same line s(:kwsplat, - s(:send, nil, :foo)) - when a multiline pair shares the same line - is expected to be same line s(:pair, - s(:sym, :a), - s(:begin)) - is expected to be same line s(:kwsplat, - s(:send, nil, :foo)) - when both pairs are on the same line - is expected to be same line s(:kwsplat, - s(:send, nil, :foo)) - #value_delta - when using colon delimiters - when keyword splat is on the same line - is expected to eq 0 - when keyword splat is ahead - is expected to eq 0 - when keyword splat is left aligned - is expected to eq 0 - when keyword splat is behind - is expected to eq 0 - when using hash rocket delimiters - when keyword splat is ahead - is expected to eq 0 - when keyword splat is left aligned - is expected to eq 0 - when keyword splat is on the same line - is expected to eq 0 - when keyword splat is behind - is expected to eq 0 - #key_delta - with alignment set to :right - when using hash rocket delimiters - when keyword splat is aligned - is expected to eq 0 - when keyword splat is on the same line - is expected to eq 0 - when keyword splat is behind - is expected to eq 0 - when keyword splat is ahead - is expected to eq 0 - when using colon delimiters - when keyword splat is behind - is expected to eq 0 - when keyword splat is on the same line - is expected to eq 0 - when keyword splat is aligned - is expected to eq 0 - when keyword splat is ahead - is expected to eq 0 - with alignment set to :left - when using hash rocket delimiters - when keyword splat is aligned - is expected to eq 0 - when keyword splat is ahead - is expected to eq 2 - when keyword splat is behind - is expected to eq -2 - when keyword splat is on the same line - is expected to eq 0 - when using colon delimiters - when keyword splat is behind - is expected to eq -2 - when keyword splat is on the same line - is expected to eq 0 - when keyword splat is aligned - is expected to eq 0 - when keyword splat is ahead - is expected to eq 2 .new - is expected to be a kind of RuboCop::AST::KeywordSplatNode - #hash_rocket? - is expected not to be hash rocket - #value - is expected to eq s(:kwsplat, - s(:send, nil, :foo)) - #key - is expected to eq s(:kwsplat, - s(:send, nil, :foo)) - #colon? - is expected not to be colon - -RuboCop::AST::ClassNode - #body - with a single expression body - is expected to be send type - with a multi-expression body - is expected to be begin type - with an empty body - is expected to be nil - .new - is expected to be a kind of RuboCop::AST::ClassNode - #parent_class - when no parent class is specified - is expected to be nil - when a parent class is specified - is expected to be const type - #identifier - is expected to be const type - -RuboCop::AST::CaseMatchNode - when using Ruby 2.7 or newer - #each_in_pattern - when not passed a block - is expected to be a kind of Enumerator - when passed a block - yields all the conditions - #else_branch - #else? - with an else statement - is expected to be sym type - without an else statement - is expected to be nil - with an empty else statement - is expected to be empty else type - #keyword - is expected to eq "case" - #in_pattern_branches - is expected to all be in pattern type - is expected to eq 3 - .new - is expected to be a kind of RuboCop::AST::CaseMatchNode - #else? - with an else statement - is expected to be else - without an else statement - is expected not to be else - #branches - when there is no else keyword - returns only then when bodies - when there is an else - with empty else - returns all the bodies - with else body - returns all the bodies + is expected to be a kind of RuboCop::AST::CaseNode RuboCop::AST::Traversal knows all current node types - for example "#{-> foo {}}" + for example %I() traverses all nodes - for example {a: if true then 42 end} + for example def f ((*, p)); end traverses all nodes - for example <<-"HERE" -#@1 -HERE + for example p <<~"E" + x + #{" y"} +E traverses all nodes - for example foo = raise bar rescue nil + for example def f foo = 1; end traverses all nodes - for example a b(c d), :e do end + for example if (a, b = foo); end traverses all nodes - for example f{ |foo:| } + for example a b(c(d)), /x/ do end traverses all nodes - for example case foo; in x, then nil; end + for example a b{c(d)}, 1.0r do end traverses all nodes - for example bar unless foo + for example def String::foo; end traverses all nodes - for example self::a, foo = foo + for example [ 1, 2 => 3 ] traverses all nodes - for example foo > 1 + for example fun(&bar) traverses all nodes - for example %q{#@@1} + for example def (foo).foo; end traverses all nodes - for example fun (1) {} + for example f{ |a| } traverses all nodes - for example a += b = raise :x + for example case; when foo; 'foo'; else 'bar'; end traverses all nodes - for example foo::fun + for example def f(&block); end traverses all nodes - for example -> do _1 + _9 end + for example :"#@@1" traverses all nodes - for example f x: -> do meth do end end + for example case foo; in A[] then true; end traverses all nodes - for example def f *r, p, &b; end + for example case foo; when 'bar'; bar; else baz; end traverses all nodes - for example meth 1 do end.fun {} + for example foo = bar = m foo traverses all nodes - for example case foo; in "a": then true; end + for example m { |(foo, bar)| } traverses all nodes - for example case foo; in **a then true; end + for example * = bar traverses all nodes - for example %r{#@1} + for example meth until foo traverses all nodes - for example foo[1, 2] + for example def f ((a, *, p)); end traverses all nodes - for example %W[#@@1] + for example def foo(...); bar(...); end traverses all nodes - for example a = b = raise :x + for example while def foo a = tap do end; end; break; end traverses all nodes - for example Bar::Foo + for example case foo; in x if true; nil; end traverses all nodes - for example p :foo, {:a => proc do end, b: proc do end} + for example foo and bar traverses all nodes - for example <<~FOO - baz\ - qux -FOO + for example tap (proc do end) traverses all nodes - for example %i[ #@1 ] + for example if foo +then bar end traverses all nodes - for example case foo; - in {a: 1 - } - false - ; end + for example %r{#@@1} traverses all nodes - for example foo[:baz => 1,] + for example return fun foo do end traverses all nodes - for example p <<~E - E + for example a b(c(d)), "x" do end traverses all nodes - for example def foo(...); bar(...); end + for example foo, bar = m foo traverses all nodes - for example fun (1).to_i + for example m "#{}#{()}" traverses all nodes - for example a b(c d), 1.0r do end + for example case foo; in self then true; end traverses all nodes - for example $10 + for example p <<~`E` + x + #{foo} +E traverses all nodes - for example [ 1, 2 => 3 ] + for example case foo; in A::B then true; end traverses all nodes - for example a b(c d), 1.0 do end + for example < ex; bar; end + for example case foo; in "#{ 'a' }": 1 then true; end traverses all nodes - for example def f (foo: 1, bar: 2, **baz, &b); end + for example assert dogs traverses all nodes - for example meth 1 do end::fun(bar) + for example :foo traverses all nodes - for example %q{#@1} + for example while class << self; a = tap do end; end; break; end traverses all nodes - for example def foo - a:b end + for example [1, *foo] traverses all nodes - for example yield foo + for example fun (1 +) traverses all nodes - for example $var = 10 + for example %q{#@@1} traverses all nodes - for example a b{c(d)}, /x/m do end + for example "#@a #@@a #$a" traverses all nodes - for example o = { -a: -1 -} + for example !foo traverses all nodes - for example case foo; in { a: 1 } then true; end + for example foo && (a, b = bar) traverses all nodes - for example if foo -then bar end + for example def f(*); end traverses all nodes - for example break fun foo do end + for example def f ((a, *)); end traverses all nodes - for example def a b: -return -end + for example def m; class << self; module M; end; end; end traverses all nodes - for example *, c, d = bar + for example yield foo traverses all nodes - for example case foo; in [x, y,] then true; end + for example a += 1 traverses all nodes - for example f{ |a| } + for example foo, bar, baz = 1, 2 traverses all nodes - for example defined? foo + for example f <<-TABLE do +TABLE +end traverses all nodes - for example p <<~E - x - y -E + for example a&.b &&= 1 traverses all nodes - for example [1, *foo] + for example "#@1" traverses all nodes - for example :'#@1' + for example foo.a += 1 traverses all nodes - for example p <<~E - x - - y -E + for example case foo; in [*x, y] then true; end traverses all nodes - for example def f(foo, bar); end + for example a += b += raise :x traverses all nodes - for example case foo; in x, y then nil; end + for example f{ |a| } traverses all nodes - for example f{ } + for example fun do end traverses all nodes - for example foo[0, 1] += m foo + for example next foo traverses all nodes - for example begin; meth; rescue; baz; else foo; ensure; bar end + for example begin meth end while foo traverses all nodes - for example def foo raise; raise A::B, ''; end + for example `#@@1` traverses all nodes - for example f{ |a| } + for example foo.a ||= 1 traverses all nodes - for example 1.. + for example case foo; in ..2 then true; end traverses all nodes - for example while def foo a = tap do end; end; break; end + for example if foo..bar; end traverses all nodes - for example { 1 => 2, :foo => "bar" } + for example break fun foo do end traverses all nodes - for example for a, b in foo; p a, b; end + for example @@var |= 10 traverses all nodes - for example a ||= 1 + for example foo += m foo traverses all nodes - for example { 'foo': 2 } + for example foo[1, 2] traverses all nodes - for example case foo; in "#{ %q{a} }": then true; end + for example yield(foo) traverses all nodes - for example def self._6; end + for example f{ |foo:| } traverses all nodes - for example begin; meth; rescue => @ex; bar; end + for example next traverses all nodes - for example foo::a += 1 + for example foo.m += raise bar rescue nil traverses all nodes - for example fun(foo, :foo => 1) + for example while foo; meth end traverses all nodes - for example 'foobar' + for example class Foo < a:b; end traverses all nodes - for example tap (proc do end) + for example foo, bar = 1, 2 traverses all nodes - for example def foo(...); super(...); end + for example m1 :k => m2 do; m3() do end; end traverses all nodes - for example case foo; in a: then true; end + for example p :foo, {a: proc do end, b: proc do end} traverses all nodes - for example break foo + for example meth 1 do end::fun(bar) traverses all nodes - for example ::Foo = 10 + for example a b(c(d)), :e do end traverses all nodes - for example foo[0, 1] ||= 2 + for example foo.C += raise(bar) rescue nil traverses all nodes - for example def x(_4) end + for example begin; meth; rescue => @ex; bar; end traverses all nodes - for example self.A, foo = foo + for example %r{#@1} traverses all nodes - for example case foo; in a: 1, _a:, ** then true; end + for example ->{ } traverses all nodes - for example def a; @@var |= 10; end + for example case foo; in ...2 then true; end traverses all nodes - for example meth 1 do end::fun bar + for example foo.C += raise bar rescue nil traverses all nodes - for example foo =~ 1 + for example foo.a &&= 1 traverses all nodes - for example foo += raise(bar) rescue nil + for example def f a, o=1, &b; end traverses all nodes - for example foo.A += m foo + for example next(foo) traverses all nodes - for example case foo; in A then true; end + for example <<-'HERE' +a\ +b +HERE traverses all nodes - for example fun(:foo => 1, &baz) + for example a # +# +.foo traverses all nodes - for example f{ |a, b,| } + for example p <<~E + x + y +E traverses all nodes - for example case foo; when 'bar'; bar; end + for example %w[] traverses all nodes - for example %{a\ -b} + for example # coding:utf-8 + "\xD0\xBF\xD1\x80\xD0\xBE\xD0\xB2\xD0\xB5\xD1\x80\xD0\xBA\xD0\xB0" traverses all nodes - for example /\xa8/n =~ "" + for example { 'foo': 2 } traverses all nodes - for example fun(f bar) + for example case foo; in x unless true; nil; end traverses all nodes - for example case foo; when 'bar' then bar; end + for example def self::foo; end traverses all nodes - for example foo, bar = 1, 2 + for example class << foo; nil; end traverses all nodes - for example /#{1}(?bar)/ =~ 'bar' + for example foo (-1.3).abs traverses all nodes - for example t=1;(foo)?t:T + for example foo[0] += raise bar rescue nil traverses all nodes - for example super() + for example case foo; in [x] then nil; end traverses all nodes - for example foo >> 1 + for example a b(c d), /x/ do end traverses all nodes - for example case foo; - in {a: - } - true - ; end + for example foo.A += 1 traverses all nodes - for example m a + b do end + for example %{a\ +b} traverses all nodes - for example B::A += 1 + for example { foo: 2 } traverses all nodes - for example def foo; end + for example begin; meth; rescue; baz; ensure; bar; end traverses all nodes - for example fun (1 -) + for example traverses all nodes - for example _2 = 1 + for example foo.A += m foo traverses all nodes - for example case foo; in 1..2 then true; end + for example a b(c d), "x" do end traverses all nodes - for example *b = bar + for example 42ri traverses all nodes - for example case foo; in 1... then true; end + for example case foo; in ::A then true; end traverses all nodes - for example !(foo..bar) + for example case foo; when 'bar', 'baz'; bar; end traverses all nodes - for example a = b += raise :x + for example meth (-1.3).abs traverses all nodes - for example :"#@@1" + for example begin; meth; rescue; foo; end traverses all nodes - for example foo = m foo + for example f x: -> do meth do end end traverses all nodes - for example case foo; in 1 | 2 then true; end + for example foo.a += m foo traverses all nodes - for example super foo + for example foo::a += 1 traverses all nodes - for example a &&= 1 + for example -> * { } traverses all nodes - for example f{ || } + for example foo = raise(bar) rescue nil traverses all nodes - for example Foo + for example case foo; + in {Foo: 42 + } + false + ; end traverses all nodes - for example ((b, )) = foo + for example foo << 1 traverses all nodes - for example a b(c(d)), /x/m do end + for example def foo(...); bar(...); end traverses all nodes - for example foo.a += m foo + for example %w{a\ +b} traverses all nodes - for example f{ |; -a -| } + for example case foo; in 1... then true; end traverses all nodes - for example a b{c(d)}, 1.0i do end + for example def f o=1, *r, &b; end traverses all nodes - for example fun() { } + for example def f ((a, *r, p)); end traverses all nodes - for example break() + for example while def self.foo; tap do end; end; break; end traverses all nodes - for example begin; meth; rescue; baz; ensure; bar; end + for example begin; meth; rescue Exception, foo; bar; end traverses all nodes - for example meth do; foo; rescue; bar; end + for example def m; class << self; A = nil; end; end traverses all nodes - for example class A; _1; end + for example "#{1}" traverses all nodes - for example def f(foo=1, bar=2); end + for example case foo; in (1) then true; end traverses all nodes - for example foo::Fun() + for example return traverses all nodes - for example __FILE__ + for example %W[foo #{bar}] traverses all nodes - for example case foo; in A::B then true; end + for example a += b = raise :x traverses all nodes - for example unless foo then bar; end + for example foo <=> 1 traverses all nodes - for example not() + for example if foo then bar; end traverses all nodes - for example :'a\ -b' + for example def a b: +return +end traverses all nodes - for example __LINE__ + for example -> { _1 + _9} traverses all nodes - for example false + for example if (bar); foo; end traverses all nodes - for example def f o=1, *r, &b; end + for example <<-"HERE" +#@@1 +HERE traverses all nodes - for example a b{c d}, 1.0r do end + for example %s{#@1} traverses all nodes - for example def f a, *r, &b; end + for example def f a, &b; end traverses all nodes - for example next foo + for example ::Foo = 10 traverses all nodes for example def f foo: -1 ; end traverses all nodes - for example super do end + for example foo | 1 traverses all nodes - for example a b(c(d)), 1.0r do end + for example A += 1 traverses all nodes - for example case; when foo; 'foo'; else 'bar'; end + for example %q(foobar) traverses all nodes - for example ::A += 1 + for example meth do; foo; rescue; bar; end traverses all nodes - for example def foo(_, _); end + for example +2.0 ** 10 traverses all nodes - for example m "#{}#{()}" + for example begin meth end until foo traverses all nodes - for example def f *r, &b; end + for example 1... traverses all nodes - for example f (g rescue nil) + for example a b(c(d)), 1.0 do end traverses all nodes - for example assert dogs + for example [ 1 => 2 ] traverses all nodes - for example def m; class << self; A = nil; end; end + for example a b(c d), 1.0 do end traverses all nodes - for example a @b do |c|;end + for example ~foo traverses all nodes - for example p <<~E - x -E + for example a b(c d), 1.0i do end traverses all nodes - for example fun(foo, :foo => 1, &baz) + for example case foo; in a:, b: then true; end traverses all nodes - for example case foo; - in {Foo: 42 - } - false - ; end + for example fun + traverses all nodes + for example while def self.foo a = tap do end; end; break; end + traverses all nodes + for example a b{c d}, :e do end + traverses all nodes + for example /\xa8/n =~ "" traverses all nodes - for example if foo then bar; else baz; end + for example a b(c(d)), /x/m do end traverses all nodes - for example foo = baz, *bar + for example module A; _1; end traverses all nodes - for example def f(foo); end + for example @foo, @@bar = *foo traverses all nodes - for example 1 in [a]; a + for example case [__FILE__, __LINE__ + 1, __ENCODING__] + in [__FILE__, __LINE__, __ENCODING__] + end traverses all nodes - for example next + for example !/wat/ traverses all nodes - for example f{ |a, *| } + for example m { |foo| } traverses all nodes - for example case foo; in 1; end + for example foo[0, 1] &&= 2 traverses all nodes - for example < * { } + for example f{ |a, &b| } traverses all nodes - for example case foo; in **nil then true; end + for example foo <= 1 traverses all nodes - for example %i[foo bar] + for example 42 traverses all nodes - for example <<-`HERE` -a\ -b -HERE + for example foo += raise(bar) rescue nil traverses all nodes - for example while class << self; tap do end; end; break; end + for example $+ traverses all nodes - for example * = bar + for example foo / 1 traverses all nodes - for example a b{c(d)}, :e do end + for example a ||= 1 traverses all nodes - for example def f(*foo); end + for example p ->() do a() do end end traverses all nodes - for example :"#@1" + for example def BEGIN; end traverses all nodes - for example yield + for example alias $a $+ traverses all nodes - for example def f &b; end + for example case foo; when 'bar' then bar; end traverses all nodes - for example if (bar; a, b = foo); end + for example foo::C ||= raise bar rescue nil traverses all nodes - for example %w[foo bar] + for example a b{c d}, 1 do end traverses all nodes - for example f{ |*| } + for example break foo traverses all nodes - for example /source/im + for example @@var = 10 traverses all nodes - for example def BEGIN; end + for example foo[bar, :baz => 1,] traverses all nodes - for example if (bar); foo; end + for example foo::Fun() traverses all nodes - for example case foo; in A[] then true; end + for example p :foo, {"a": proc do end, b: proc do end} traverses all nodes - for example return() + for example while def foo; tap do end; end; break; end traverses all nodes - for example case foo; when 'bar', 'baz'; bar; end + for example super do end traverses all nodes - for example $+ + for example %W"#{1}" traverses all nodes - for example foo.C += raise(bar) rescue nil + for example -> do _1 + _9 end traverses all nodes - for example 42i + for example begin; meth; rescue; foo; else; bar; end + traverses all nodes + for example !m foo traverses all nodes for example def foo =begin =end end traverses all nodes - for example foo.a ||= 1 - traverses all nodes - for example meth until foo - traverses all nodes - for example unless foo then bar; else baz; end + for example not(foo) traverses all nodes - for example case foo; in ** then true; end + for example -> do end traverses all nodes - for example :'foo' + for example "#@@1" traverses all nodes - for example p :foo, {a: proc do end, b: proc do end} + for example case foo; when 'bar'; bar; end traverses all nodes - for example case foo; in ::A then true; end + for example meth 1 do end.fun bar traverses all nodes - for example ->(a; foo, bar) { } + for example foo::a = 1 traverses all nodes - for example %i[] + for example foo.a = 1 traverses all nodes - for example f{ |*r, p, &b| } + for example def f a, o=1, *r, p, &b; end traverses all nodes - for example p <<~E - x - y -E + for example def String=; end traverses all nodes - for example m1 :k => m2 do; m3() do end; end + for example fun (1).to_i traverses all nodes - for example foo = raise(bar) rescue nil + for example f{ |a, b,| } traverses all nodes - for example case foo; in "#{ 'a' }": then true; end + for example case foo; in [*, x] then true; end traverses all nodes - for example module Foo; end + for example case foo; in { a: 1 } then true; end traverses all nodes - for example %Q{#@1} + for example _1 traverses all nodes - for example "#{1}" + for example self.a, self[1, 2] = foo traverses all nodes - for example def self::foo; end + for example foo[:baz => 1,] traverses all nodes - for example next() + for example $var = 10 traverses all nodes - for example <<`HERE` -foo -bar -HERE + for example a b{c(d)}, /x/m do end traverses all nodes - for example begin; meth; rescue; foo; else; bar; end + for example ?a traverses all nodes - for example def f a, o=1, &b; end + for example m ->(a: ->{_1}) {a} traverses all nodes - for example a&.b + for example case foo; in "a": then true; end traverses all nodes - for example foo.A = 1 + for example a b{c d}, /x/m do end traverses all nodes - for example yield(foo) + for example case foo; in A then true; end traverses all nodes - for example case foo; in 1 => a then true; end + for example f{ |a, o=1, o1=2, *r, &b| } traverses all nodes - for example %I() + for example /#@@1/ traverses all nodes - for example f{ | | } + for example foo "#{(1+1).to_i}" do; end traverses all nodes - for example retry + for example def foo(_, _); end traverses all nodes - for example m def x(); end; 1.tap do end + for example %w[foo bar] traverses all nodes - for example f{ |o=1, *r, &b| } + for example %w[ #@1 ] traverses all nodes - for example case foo; in [x, y, *z] then true; end + for example defined? @foo traverses all nodes - for example case foo; in [x, *, y] then true; end + for example END { 1 } traverses all nodes - for example foo ^ 1 + for example self::A, foo = foo traverses all nodes - for example a b(c d), 1.0i do end + for example m ->(a = ->{_1}) {a} traverses all nodes - for example -foo + for example super foo traverses all nodes - for example class << foo; nil; end + for example case 1; in 2; 3; else; 4; end traverses all nodes - for example ::A, foo = foo + for example m do _1 + _9 end traverses all nodes - for example class Foo end + for example %w[ #@@1 ] traverses all nodes - for example m [] do end + for example f (g rescue nil) traverses all nodes - for example begin; meth; rescue Exception; bar; end + for example %Q{#@@1} traverses all nodes - for example foo.fun + for example case foo; in [x, y, *z] then true; end traverses all nodes - for example { } + for example a, *, c = bar traverses all nodes - for example p <<~E - x - -y -E + for example "a\ +b" traverses all nodes - for example foo.m += raise(bar) rescue nil + for example case foo; in "a": 1 then true; end traverses all nodes - for example if foo; bar; elsif baz; 1; else 2; end + for example def foo() a:b end traverses all nodes - for example %x{#@@1} + for example f{ |;a| } traverses all nodes - for example # coding:utf-8 - "\xD0\xBF\xD1\x80\xD0\xBE\xD0\xB2\xD0\xB5\xD1\x80\xD0\xBA\xD0\xB0" + for example fun() { } traverses all nodes - for example if foo; bar; end + for example lambda{|;a|a} traverses all nodes - for example alias :foo bar + for example foo = m foo traverses all nodes - for example a, (b, c) = foo + for example /a\ +b/ traverses all nodes - for example unless foo; bar; end + for example defined? foo traverses all nodes - for example f <<-TABLE do -TABLE -end + for example def f ((a, *r)); end traverses all nodes - for example def f ((a, *r, p)); end + for example until foo; meth end traverses all nodes - for example 1...2 + for example def a; @@var |= 10; end traverses all nodes - for example def self.foo; end + for example foo::m += raise bar rescue nil traverses all nodes - for example def f o=1, *r, p, &b; end + for example def f (((a))); end traverses all nodes - for example p ->() do a() do end end + for example begin end traverses all nodes - for example self.a, self[1, 2] = foo + for example meth 1 do end.fun(bar) traverses all nodes - for example def (foo).foo; end + for example a b{c(d)}, 1.0 do end traverses all nodes - for example class A < B -end + for example $10 traverses all nodes - for example foo / 1 + for example __LINE__ traverses all nodes - for example ..100 + for example case foo; in [x, y,] then true; end traverses all nodes - for example foo === 1 + for example :"#@1" traverses all nodes - for example def f *, **; end + for example `#@1` traverses all nodes - for example let () { m(a) do; end } + for example bar unless foo traverses all nodes - for example %W"#{1}" + for example 1..2 traverses all nodes - for example 'a\ -b' + for example not m foo traverses all nodes - for example %i[ #@@1 ] + for example for a, b in foo; p a, b; end traverses all nodes - for example case 1; in 2; 3; else; 4; end + for example a b{c(d)}, 1 do end traverses all nodes - for example p <<~E " y" - x -E + for example %i[foo bar] traverses all nodes - for example %q(foobar) + for example foo > 1 traverses all nodes - for example case foo; in [x, *y, z] then true; end + for example assert do: true traverses all nodes - for example @@var |= 10 + for example @a |= 1 traverses all nodes - for example p -> { :hello }, a: 1 do end + for example `foo#{bar}baz` traverses all nodes for example () traverses all nodes - for example begin foo!; bar! end - traverses all nodes - for example def f ((*r)); end - traverses all nodes - for example foo += raise bar rescue nil - traverses all nodes - for example p <<~E - x - y -E + for example break(foo) traverses all nodes - for example -1.33 + for example def String; end traverses all nodes - for example f{ |a,| } + for example BEGIN { 1 } traverses all nodes - for example next(foo) + for example foo::a += m foo traverses all nodes - for example td (1_500).toString(); td.num do; end + for example proc {|_3|} traverses all nodes - for example case foo; - in a: {b:}, c: - p c - ; end + for example foo % 1 traverses all nodes - for example fun + for example <<~FOO + baz\ + qux +FOO traverses all nodes - for example fun(&bar) + for example a = 1; a b: 1 traverses all nodes - for example -> do end + for example `foobar` traverses all nodes - for example a b{c(d)}, 1.0 do end + when given an unexpected AST + with too few children + raises debugging error + with too many children + raises debugging error + for example <<-`HERE` +#@1 +HERE traverses all nodes - for example m { |(foo, bar)| } + for example __ENCODING__ traverses all nodes - for example @foo, @@bar = *foo + for example f{ |; +a +| } traverses all nodes - for example true ? 1.tap do |n| p n end : 0 + for example def self.foo; end traverses all nodes - for example a b(c(d)), :e do end + for example Foo = 10 traverses all nodes - for example !foo + for example begin; meth; rescue foo => ex; bar; end traverses all nodes - for example @@foo + for example for a in foo; p a; end traverses all nodes - for example %r{a\ + for example %W{a\ b} traverses all nodes - for example foo, bar, baz = 1, 2 + for example case foo; in A(1, 2) then true; end traverses all nodes - for example @a |= 1 + for example foo::fun (1) {} traverses all nodes - for example super foo, bar do end + for example B::A += 1 traverses all nodes - for example def f o=1, &b; end + for example break traverses all nodes - for example def f ((a, a1)); end + for example foo - 1 traverses all nodes - for example a b{c(d)}, "x" do end + for example @var = 10 traverses all nodes - for example "foo#{bar}baz" + for example fun(f bar) traverses all nodes - for example a, *b = bar + for example %i{a\ +b} traverses all nodes - for example case foo; in self then true; end + for example f{ |o=1, *r, p, &b| } traverses all nodes - for example meth[] {} + for example f{ |*, &b| } traverses all nodes - for example foo[m bar] + for example fun (f bar) traverses all nodes - for example def f(**); end + for example f{ |a, o=1, *r, p, &b| } traverses all nodes - for example foo[1, 2] = 3 + for example <<-`HERE` +#@@1 +HERE traverses all nodes - for example p p{p(p);p p}, tap do end + for example class Foo < Bar; end traverses all nodes - for example def f ((*, p)); end + for example f{ |*s| } traverses all nodes - for example begin; meth; rescue; foo; end + for example foo[0, 1] += m foo traverses all nodes - for example `#@1` + for example def foo(...); super(...); end traverses all nodes - for example %I[#@1] + for example f{ |foo: 1, bar: 2, **baz, &b| } traverses all nodes - for example def x; ::A ||= 1; end + for example +foo traverses all nodes - for example meth while foo + for example f { || a:b } traverses all nodes - for example m = -> *args do end + for example -> (arg={}) {} traverses all nodes - for example %W[foo #{bar}foo#@baz] + for example a # +# +&.foo traverses all nodes - for example a = 1; a b: 1 + for example let (:a) { m do; end } traverses all nodes - for example %w[ #@1 ] + for example ->(a) { } traverses all nodes - for example redo + for example case foo; in **nil then true; end traverses all nodes - for example foo <=> 1 + for example return() traverses all nodes - for example f{ |&b| } + for example def x; self::A ||= 1; end traverses all nodes - for example a b{c d}, /x/ do end + for example 'a\ +b' traverses all nodes - for example meth rescue bar + for example foo = *bar traverses all nodes - for example foo, bar = m foo + for example foo.A = 1 traverses all nodes - for example foo::m += raise bar rescue nil + for example def foo raise; raise A::B, ''; end traverses all nodes - for example def foo(_a, _a); end + for example a b{c d}, 1.0i do end traverses all nodes - for example next fun foo do end + for example f{ |o=1, *r, &b| } traverses all nodes for example p <<~E x @@ -3352,252 +4989,244 @@ traverses all nodes for example /#@1/ traverses all nodes - for example -> a: { } - traverses all nodes - for example a b(c(d)), /x/ do end - traverses all nodes - for example def f foo = 1; end + for example begin; meth; rescue Exception; bar; end traverses all nodes - for example def f a, &b; end + for example foo::A += m foo traverses all nodes - for example def f (((a))); end + for example desc "foo" do end traverses all nodes - for example __ENCODING__ + for example case foo; in { a: 1, } then true; end traverses all nodes - for example foo.m += raise bar rescue nil + for example undef foo, :bar, :"foo#{1}" traverses all nodes - for example case foo; in a: 1 then true; end + for example not() traverses all nodes - for example %W() + for example a b(c d), /x/m do end traverses all nodes - for example foo += m foo + for example foo::Fun bar traverses all nodes - for example %I{a\ -b} + for example retry traverses all nodes - for example case foo; in (1) then true; end + for example f{ |&b| } traverses all nodes - for example "foo#@a" "bar" + for example def f(foo, bar); end traverses all nodes - for example case foo; in * then nil; end + for example ->{ } traverses all nodes - for example a ? b & '': nil + for example next fun foo do end traverses all nodes - for example foo || (a, b = bar) + for example <<-E + 1 \ + 2 + 3 +E traverses all nodes - for example def self.m; _1; end + for example def f **baz, &b; end traverses all nodes - for example a # - # -&.foo + for example case foo; in A() then true; end traverses all nodes - for example m ->(a: ->{_1}) {a} + for example %s{a\ +b} traverses all nodes - for example case foo; in ...2 then true; end + for example { } traverses all nodes - for example $foo + for example 1.. traverses all nodes - for example p <<~"E" - x - #{" y"} -E + for example unless foo then bar; else baz; end traverses all nodes - for example "a\ -b" + for example {a: if true then 42 end} traverses all nodes - for example case foo; in [*x, y] then true; end + for example break() traverses all nodes - for example a b(c d), "x" do end + for example __FILE__ traverses all nodes - for example def f o=1, p, &b; end + for example m "#{[]}" traverses all nodes - for example foo < 1 + for example module ::Foo; end traverses all nodes - for example for a in foo do p a; end + for example foo[1, 2] traverses all nodes - for example ::Foo + for example 1.33 traverses all nodes - for example case foo; in x if true; nil; end + for example def f(foo:); end traverses all nodes - for example while class Foo a = tap do end; end; break; end + for example p <<~E + x + y +E traverses all nodes - for example '#@@1' + for example def String.foo; end traverses all nodes - for example case foo; in A() then true; end + for example *, c, d = bar traverses all nodes - for example foo::A = 1 + for example case foo; in [x, y] then true; end traverses all nodes - for example def f(**nil); end + for example p <<~E + x + y +E traverses all nodes - for example case foo; - in {a: - 2} - false - ; end + for example case foo; in x, *y, z then nil; end traverses all nodes - for example fun (1) + for example unless foo; bar; end traverses all nodes - for example foo "#{(1+1).to_i}" do; end + for example def foo + a:b end traverses all nodes - for example self::A, foo = foo + for example %x{a\ +b} traverses all nodes - for example m { |foo| } + for example p <<~"E" + x + #{foo} +E traverses all nodes - for example case foo; in "#{ %Q{a} }": then true; end + for example '#@1' traverses all nodes - for example END { 1 } + for example m [] do end traverses all nodes for example <<-`HERE` -#@1 +a\ +b HERE traverses all nodes - for example def until; end - traverses all nodes - for example case [__FILE__, __LINE__ + 1, __ENCODING__] - in [__FILE__, __LINE__, __ENCODING__] - end - traverses all nodes - for example p begin 1.times do 1 end end - traverses all nodes - for example while def self.foo; tap do end; end; break; end + for example ((b, )) = foo traverses all nodes - for example fun(1) { } + for example foo::m += raise(bar) rescue nil traverses all nodes - for example f{ |a, &b| } + for example case foo; + in {a: + 2} + false + ; end traverses all nodes - for example ->(a) { } + for example %i[ #@1 ] traverses all nodes - for example def f ((*)); end + for example p <<~E " y" + x +E traverses all nodes - for example case foo; in 1, "a", [], {} then nil; end + for example 42.1ri traverses all nodes - for example foo[1, 2] + for example :"a\ +b" traverses all nodes - for example *b, c = bar + for example foo[bar,] traverses all nodes - for example 1.33 + for example def f(foo: 1); end traverses all nodes - for example not m foo + for example fun! traverses all nodes - for example fun () {} + for example case foo; in x, y then nil; end traverses all nodes - for example foo + 1 + for example case foo; in [x, *, y] then true; end traverses all nodes - for example m { _1 + _9 } + for example case foo; in {} then true; end traverses all nodes - for example 1... + for example alias :foo bar traverses all nodes - for example f{ |a, *, &b| } + for example ..100 traverses all nodes - for example /#)/x + when a class defines `on_block_pass` + calls it for all block-pass arguments + for example { 'foo': 2, 'bar': {}} traverses all nodes - for example undef foo, :bar, :"foo#{1}" + for example case foo; in *x then nil; end traverses all nodes - for example fun(foo, *bar) + for example false ? raise do end : tap do end traverses all nodes - for example %Q{a\ -b} + for example p <<~E + x + \ y +E traverses all nodes - for example foo and bar + for example def END; end traverses all nodes - for example a # - # -.foo + for example o = { +a: +1 +} traverses all nodes - for example -> (arg={}) {} + for example case foo; in x, then nil; end traverses all nodes - for example <<-E - 1 \ - 2 - 3 -E + for example 42r traverses all nodes - for example a b{c(d)}, /x/ do end + for example Bar::Foo traverses all nodes - for example begin; rescue LoadError; else; end + for example def f(**nil); end traverses all nodes - for example `#@@1` + for example def f(**); end traverses all nodes - for example foo[1, 2] = 3 + for example %x{#@@1} traverses all nodes - for example a b{c d}, 1.0i do end + for example f{ |a, o=1, p, &b| } traverses all nodes - for example def f(&block); end + for example @@foo traverses all nodes - for example '#@1' + for example a b(c d), 1 do end traverses all nodes - for example def END; end + for example p p{p(p);p p}, tap do end traverses all nodes - for example /#@@1/ + for example p begin 1.times do 1 end end traverses all nodes - for example def f a, o=1, p, &b; end + for example case foo; in ** then true; end traverses all nodes - for example begin ensure end + for example meth 1 do end.fun {} traverses all nodes - for example f{ |;a| } + for example yield() traverses all nodes - for example if foo then bar; end + for example case foo; in 1...2 then true; end traverses all nodes - for example !m foo + for example %I[foo#{bar}] traverses all nodes - for example :"foo#{bar}baz" + for example def f(foo=1, bar=2); end traverses all nodes - for example f{ |a, o=1, o1=2, *r, &b| } + for example -2 ** 10 traverses all nodes - for example A += 1 + for example meth rescue bar traverses all nodes - for example p <<~"E" - x - #{foo} -E + for example while not (true) do end traverses all nodes - for example 42.1i + for example foo::(1) traverses all nodes - for example foo[bar, :baz => 1,] + for example a @b do |c|;end traverses all nodes - for example <<~E - 1 \ - 2 - 3 -E + for example case; when foo; 'foo'; end traverses all nodes - for example foo::C ||= raise(bar) rescue nil + for example f{ |o=1, &b| } traverses all nodes - for example %w[ #@@1 ] + for example case foo; in 1 | 2 then true; end traverses all nodes - for example while def self.foo a = tap do end; end; break; end + for example if foo; bar; else baz; end traverses all nodes - when a class defines `on_block_pass` - calls it for all block-pass arguments - for example p <<~E - x - y -E + for example ::Foo traverses all nodes - for example def f a, *r, p, &b; end + for example ::A += 1 traverses all nodes - for example defined? @foo + for example %r{a\ +b} traverses all nodes - for example a b{c d}, 1.0 do end + for example case foo; in x, y, then nil; end traverses all nodes - for example case foo; in A(x:) then true; end + for example if /wat/; end traverses all nodes - for example %s{#@@1} + for example foo = raise bar rescue nil traverses all nodes - for example %s{#@1} + for example def f ((*r, p)); end traverses all nodes - for example 42 + for example super traverses all nodes - for example foo[bar,] + for example ->(a; foo, bar) { } traverses all nodes - for example a # -# -.foo + for example f{ |a| } traverses all nodes - for example foo * 1 + for example '#@@1' traverses all nodes - for example %s{a\ -b} + for example case foo; + in {a: + } + true + ; end traverses all nodes for example # Extracted from `parser` gem. # Add the following code at the beginning of `def assert_parses`: @@ -3608,1726 +5237,812 @@ alias $a $b traverses all nodes - for example def f a, o=1, *r, p, &b; end + for example unless foo; bar; else baz; end traverses all nodes - for example %x{a\ -b} + for example !(foo..bar) traverses all nodes - for example +foo + for example def foo(_a, _a); end traverses all nodes - for example %I[foo #{bar}] + for example true traverses all nodes - for example case foo; in [x, y] then true; end + for example m { |**nil| } traverses all nodes - for example module ::Foo; end + for example Foo traverses all nodes - for example while class << self; a = tap do end; end; break; end + for example if foo then bar; else baz; end traverses all nodes - for example until foo do meth end + for example def f ; end traverses all nodes - for example not foo + for example $foo traverses all nodes - for example a b{c d}, 1 do end + for example self.A, foo = foo traverses all nodes - for example class Foo < Bar; end + for example def f *r, p, &b; end traverses all nodes - for example fun(*bar) + for example a = b += raise :x traverses all nodes - for example p <<~"E" - x\n y -E + for example def foo; end traverses all nodes - for example case foo; in { a: 1, } then true; end + for example class << foo; _1; end traverses all nodes - for example a&.b = 1 + for example meth 1 do end::fun bar traverses all nodes - for example a b{c(d)}, 1 do end + for example f{ |a, c| } traverses all nodes - for example ~foo + for example %i[ #@@1 ] traverses all nodes - for example f{ |*s, &b| } + for example self traverses all nodes - for example desc "foo" do end + for example <<'HERE' +foo +bar +HERE traverses all nodes - for example alias $a $+ + for example def until; end traverses all nodes - for example f(a ? "a":1) + for example case foo; when 1, *baz; bar; when *foo; end traverses all nodes - for example "#@a #@@a #$a" + for example def self._6; end traverses all nodes - for example %W{a\ -b} + for example t=1;(foo)?t:T traverses all nodes - for example case foo; in A[1, 2] then true; end + for example -foo traverses all nodes - for example begin meth end while foo + for example `a\ +b` traverses all nodes - for example f{ |a, o=1, *r, p, &b| } + for example begin; meth; rescue; baz; else foo; ensure; bar end traverses all nodes - for example foo (-1.3).abs + for example case 1; in 2; 3; else; end traverses all nodes - for example f { || a:b } + for example /#)/x traverses all nodes - when a class defines on_arg - calls it for all arguments - for example %I[foo#{bar}] + for example bar def foo; self.each do end end traverses all nodes - for example foo or bar + for example def f a, o=1, p, &b; end traverses all nodes - for example if foo...bar; end + for example def f o=1, p, &b; end traverses all nodes - for example foo::(1) + for example <<~E + 1 \ + 2 + 3 +E traverses all nodes - for example foo::m += raise(bar) rescue nil + for example a b{c(d)}, :e do end traverses all nodes - for example a b(c d), /x/ do end + for example foo = bar, 1 traverses all nodes - for example foo::fun bar + for example /#{1}(?bar)/ =~ 'bar' traverses all nodes - for example case foo; in ^foo then nil; end + for example begin; meth; ensure; bar; end traverses all nodes - for example return(foo) + for example case foo; + in {a: 1 + } + false + ; end traverses all nodes - for example <<-'HERE' -#@@1 -HERE + for example foo::fun bar traverses all nodes - for example break(foo) + for example while class Foo a = tap do end; end; break; end traverses all nodes - for example defined?(foo) + for example 'foobar' traverses all nodes - for example foo = bar, 1 + for example %W[foo #{bar}foo#@baz] traverses all nodes - for example def f(**foo); end + for example fun(foo, *bar, &baz) traverses all nodes - for example begin; meth; rescue Exception, foo; bar; end + for example a, b = *foo, bar traverses all nodes - for example let (:a) { m do; end } + for example fun(foo, :foo => 1) traverses all nodes - for example fun(*bar, &baz) + for example a&.b traverses all nodes - for example <<-'HERE' -a\ -b -HERE + for example for a in foo do p a; end traverses all nodes - for example foo & 1 + for example a = b = raise :x traverses all nodes - for example def f ((a, *, p)); end + for example _2 = 1 traverses all nodes - for example %r{#@@1} + for example begin ensure end traverses all nodes - for example if /wat/; end + for example def x; ::A ||= 1; end traverses all nodes - for example foo == 1 + for example foo traverses all nodes - for example case foo; in ->{ 42 } then true; end + for example a b(c d), 1.0r do end traverses all nodes - for example module Bar::Foo; end + for example case foo; + in a: {b:}, c: + p c + ; end traverses all nodes - for example module A; _1; end + for example true ? 1.tap do |n| p n end : 0 traverses all nodes - for example a, b = *foo, bar + for example %W() traverses all nodes - for example m do _1 + _9 end + for example :'foo' traverses all nodes - for example "#@1" + for example fun(*bar, &baz) traverses all nodes - for example ?a + for example foo + 1 traverses all nodes - for example a, *, c = bar + for example case foo; in 1..2 then true; end traverses all nodes - for example foo + for example "#{-> foo {}}" traverses all nodes - for example `foobar` + for example f{ |*s, &b| } traverses all nodes - for example <<-`HERE` -#@@1 -HERE + for example -> do rescue; end traverses all nodes - for example :"a\ -b" + for example m { _1 + _9 } traverses all nodes - for example :'#@@1' + for example foo.fun (1) {} traverses all nodes - for example ->{ } + for example "foo#@a" "bar" traverses all nodes - for example f{ |*s| } + for example :'#@@1' traverses all nodes - for example def f(foo:); end + for example /(?bar)/ =~ 'bar'; match traverses all nodes - for example case foo; in "#{ %q{a} }": 1 then true; end + for example foo.(1) traverses all nodes - for example %W[foo #{bar}] + for example def f (foo: 1, bar: 2, **baz, &b); end traverses all nodes - for example lambda{|;a|a} + for example while class << self; tap do end; end; break; end traverses all nodes - for example @var = 10 + for example case foo; in [x, *y, z] then true; end traverses all nodes - for example begin; meth; ensure; bar; end + for example a # + # +&.foo traverses all nodes - for example f{ |o=1, p, &b| } + for example 42.1r traverses all nodes - for example :foo + for example { foo: 2, **bar } traverses all nodes - for example BEGIN { 1 } + for example td (1_500).toString(); td.num do; end traverses all nodes - for example class << foo; _1; end + for example f{ |a, *r, p, &b| } traverses all nodes - for example case foo; in x, *y, z then nil; end + for example proc {_1 = nil} traverses all nodes - for example [*foo] + for example %I[foo #{bar}] traverses all nodes - for example -> do rescue; end + for example foo || (a, b = bar) traverses all nodes - for example if foo..bar; end + for example unless foo then bar; end traverses all nodes - for example 1..2 + for example a b(c(d)), 1.0i do end traverses all nodes - for example %W[#@1] + for example <<-'HERE' +#@@1 +HERE traverses all nodes - for example def f ; end + for example p <<~E + x +E traverses all nodes - for example -42 + for example !(a, b = foo) traverses all nodes - for example a b(c d), 1 do end + for example -1.33 traverses all nodes - for example foo&.bar {} + for example %i[] traverses all nodes - for example yield() + for example *b, c = bar traverses all nodes - for example foo[0, 1] &&= 2 + for example ::A, foo = foo traverses all nodes - for example for a in foo; p a; end + for example p <<~E + x + + y +E traverses all nodes - for example super(foo) + for example %{#@1} traverses all nodes - for example foo.A += 1 + for example foo += meth rescue bar traverses all nodes - for example case foo; in [x] then nil; end + for example [/()\1/, ?#] traverses all nodes - for example fun { } + for example foo[0, 1] ||= 2 traverses all nodes - for example def String.foo; end + for example until foo do meth end traverses all nodes - for example f{ |o=1, &b| } + for example case foo; in a: 1 then true; end traverses all nodes - for example "#@@1" + for example fun(foo, *bar) traverses all nodes - for example p <<~E - x - y -E + for example p :foo, {** proc do end, b: proc do end} traverses all nodes - for example return + for example foo * 1 traverses all nodes - for example fun(:foo => 1) + for example foo::A = 1 traverses all nodes - for example [1, *foo, 2] + for example foo && bar traverses all nodes - for example ->(**nil) {} + for example a, * = bar traverses all nodes - when given an unexpected AST - with too many children - raises debugging error - with too few children - raises debugging error - for example def f ((a, *r)); end + for example foo[0] += raise(bar) rescue nil traverses all nodes - for example def f(foo: 1); end + for example foo == 1 traverses all nodes - for example true + for example a ? b & '': nil traverses all nodes - for example case foo; in x unless true; nil; end + for example super(foo) traverses all nodes - for example %w{a\ -b} + for example foo = meth rescue bar traverses all nodes - for example case 1; in 2; 3; else; end + for example foo ** 1 traverses all nodes - for example foo || bar + for example p <<~E + x + +y +E traverses all nodes - for example <<'HERE' -foo -bar -HERE + for example foo[0, 1] += 2 traverses all nodes - for example foo = *bar + for example not foo traverses all nodes - for example `foo#{bar}baz` + for example case foo; in a: then true; end traverses all nodes - for example f{ |*, &b| } + for example foo =~ 1 traverses all nodes - for example a b(c(d)), 1.0i do end + for example *b = bar traverses all nodes - for example while foo do meth end + for example self::a, foo = foo traverses all nodes - for example begin meth end until foo + for example p <<~E +E traverses all nodes - for example { foo: 2 } + for example case foo; in * then nil; end traverses all nodes - for example f{ |foo: 1, bar: 2, **baz, &b| } + for example case foo; in ->{ 42 } then true; end traverses all nodes - for example super + for example meth while foo traverses all nodes - for example def String=; end + for example foo ^ 1 traverses all nodes - for example until foo; meth end + for example f{ |foo: 1, &b| } traverses all nodes - for example unless foo; bar; else baz; end + for example class A < B +end traverses all nodes - for example a, * = bar + for example p <<~"E" + x\n y +E traverses all nodes - for example foo !~ 1 + for example fun(:foo => 1) traverses all nodes - for example ->{ } + for example foo&.bar {} traverses all nodes - for example foo ** 1 + for example def f(foo); end traverses all nodes - for example -> a: 1 { } + for example %Q{a\ +b} traverses all nodes - for example (foo, bar) = 1, 2 + for example case foo; in **a then true; end traverses all nodes - for example f{ |foo: 1, &b| } + for example next() traverses all nodes - for example def f **baz, &b; end + for example var = 10; var traverses all nodes - for example def x; self::A ||= 1; end + for example ...100 traverses all nodes - for example bar if foo + for example foo != 1 traverses all nodes - for example case foo; in [x, y, *] then true; end + for example m [], 1 do end traverses all nodes - for example +42 + for example def f a, *r, &b; end traverses all nodes - for example f{ |a, *s| } + for example foo[m bar] traverses all nodes - for example %w[] + for example def f *, **; end traverses all nodes - for example foo::a += m foo + for example /foo#{bar}baz/ traverses all nodes - for example a b{c d}, /x/m do end + for example a &&= 1 traverses all nodes - for example Foo = 10 + when a class defines on_arg + calls it for all arguments + for example fun(foo, :foo => 1, &baz) traverses all nodes - for example case foo; in ..2 then true; end + for example nil traverses all nodes - for example foo += meth rescue bar + for example case foo; in a: 1, b: 2 then true; end traverses all nodes - for example m [], 1 do end + for example f{ |*| } traverses all nodes - for example f{ |a, o=1, p, &b| } + for example fun () {} traverses all nodes - for example -> (a) { } + for example <<`HERE` +foo +bar +HERE traverses all nodes - for example meth 1 do end.fun(bar) {} + for example super() traverses all nodes - for example _1 + for example fun(1) { } traverses all nodes - for example %q{a\ -b} + for example foo, bar = meth rescue [1, 2] traverses all nodes - for example foo.a &&= 1 + for example def f a, o=1, *r, &b; end traverses all nodes - for example def m; class << self; module M; end; end; end + for example def f(*foo); end traverses all nodes - for example %I[#@@1] + for example (foo, bar) = 1, 2 traverses all nodes - for example -> { _1 + _9} + for example case foo; in [x,] then nil; end traverses all nodes - for example f{ |a, *r, p, &b| } + for example %Q{#@1} traverses all nodes - for example foo::A += m foo + for example p <<~E + x + y +E traverses all nodes - for example foo = bar = m foo + for example a b(c(d)), 1 do end traverses all nodes - for example def f(*); end + for example %W[#@@1] traverses all nodes - for example /a\ -b/ + for example { 1 => 2 } traverses all nodes - for example + for example p -> { :hello }, a: 1 do end traverses all nodes - for example __ENCODING__ + for example fun (1) traverses all nodes - for example foo - 1 + for example def foo(...); end traverses all nodes - for example fun do end + for example foo.fun traverses all nodes - for example ->(scope) {}; scope + for example 42.1i traverses all nodes - for example <<-"HERE" -a\ -b -HERE + for example a b{c(d)}, /x/ do end traverses all nodes - for example def f ((*r, p)); end + for example 1...2 traverses all nodes - for example class Foo; end + for example fun(1) traverses all nodes - for example Bar::Foo = 10 + for example case foo; in ^foo then nil; end traverses all nodes - for example <<-'HERE' -#@1 -HERE + for example case foo; in 1 => a then true; end traverses all nodes - for example false ? raise {} : tap {} + for example %{#@@1} traverses all nodes - for example proc {|_3|} + for example case foo; in A[x:] then true; end traverses all nodes - for example case foo; in *x, y, z then nil; end + for example if foo; bar; end traverses all nodes - for example def foo(...); bar(...); end + for example foo === 1 traverses all nodes - for example foo.fun bar + for example def f ((*)); end traverses all nodes - for example -2 ** 10 + for example false traverses all nodes - for example !(foo...bar) + for example -> a: 1 { } traverses all nodes - for example while foo; meth end + for example %q{a\ +b} traverses all nodes - for example !/wat/ + for example meth 1 do end.fun(bar) {} traverses all nodes - for example fun(foo, *bar, &baz) + for example a b(c d), :e do end traverses all nodes - for example foo::Fun bar + for example p :foo, {proc do end => proc do end, b: proc do end} traverses all nodes - for example return fun foo do end + for example case foo; in a: 1, _a:, ** then true; end traverses all nodes - for example not(foo) + for example [*foo] traverses all nodes - for example [1, 2] + for example ->(scope) {}; scope traverses all nodes - for example %x{#@1} + for example -> (a) { } traverses all nodes - for example @foo + for example %I{a\ +b} traverses all nodes - for example m "#{[]}" + for example p <<~E + E traverses all nodes - for example a b(c d), /x/m do end + for example case foo; in A[1, 2] then true; end traverses all nodes - for example f{ |**baz, &b| } + for example :"foo#{bar}baz" traverses all nodes - for example p <<~E -E + for example foo >= 1 traverses all nodes - for example def f a, o=1, *r, &b; end + for example foo[1, 2] = 3 traverses all nodes - for example case foo; in a: 1, b: 2 then true; end + for example a b{c(d)}, 1.0i do end traverses all nodes - for example def foo(...); end + for example if foo; bar; elsif baz; 1; else 2; end traverses all nodes - for example +2.0 ** 10 + for example return foo traverses all nodes - for example @@var = 10 + for example f{ } traverses all nodes - for example case foo; in 1...2 then true; end + for example def f *r, &b; end traverses all nodes - for example /foo#{bar}baz/ + for example case foo; in A(x:) then true; end traverses all nodes - for example foo, bar = meth rescue [1, 2] + for example def f o=1, &b; end traverses all nodes - for example foo[0] += raise(bar) rescue nil + for example -2.0 ** 10 traverses all nodes - for example case foo; in x, y, then nil; end + for example p <<~E + x + y +E traverses all nodes - for example self + for example m = -> *args do end traverses all nodes - for example foo << 1 + for example return(foo) traverses all nodes - for example [ 1 => 2 ] + for example begin; meth; rescue => ex; bar; end traverses all nodes - for example case foo; when 'bar'; bar; else baz; end + for example begin foo!; bar! end traverses all nodes - for example meth 1 do end.fun(bar) + for example def f foo: +; end traverses all nodes - for example case foo; in 1.. then true; end + for example foo ? 1 : 2 traverses all nodes - for example class Foo < a:b; end + for example false ? raise {} : tap {} traverses all nodes - for example begin; meth; rescue foo => ex; bar; end + for example foo::fun traverses all nodes - for example m ->(a = ->{_1}) {a} + for example foo || bar traverses all nodes - for example f{ |a| } + for example begin; rescue LoadError; else; end traverses all nodes - for example meth 1 do end.fun bar + for example def x(_4) end traverses all nodes - for example foo != 1 + for example foo < 1 traverses all nodes - for example break + for example @foo traverses all nodes - for example fun(1) + for example ->(**nil) {} traverses all nodes - for example assert do: true + for example a, *b = bar traverses all nodes - for example a b{c d}, :e do end + for example a b{c(d)}, "x" do end traverses all nodes - for example case foo; in [*, x] then true; end + for example def f (foo: 1, &b); end traverses all nodes - for example case; when foo; 'foo'; end + for example defined?(foo) traverses all nodes - for example a&.b &&= 1 + for example a, *b, c = bar traverses all nodes - for example a b(c(d)), 1.0 do end + for example fun { } traverses all nodes - for example 42.1ri + for example a b{c d}, /x/ do end traverses all nodes - for example foo::C ||= raise bar rescue nil + for example a # + # +.foo traverses all nodes - for example foo.fun (1) {} + for example case foo; in x then x; end traverses all nodes - for example a b(c(d)), 1 do end + for example f{ |a, *, &b| } traverses all nodes - for example meth 1 do end.fun bar do end + for example __ENCODING__ traverses all nodes - for example foo >= 1 + for example f{ || } traverses all nodes - for example def String; end + for example case foo; in "#{ %Q{a} }": then true; end traverses all nodes - for example case foo; in x then x; end + for example %q{#@1} traverses all nodes - for example %Q{#@@1} + for example def f(**foo); end traverses all nodes - for example foo[0, 1] += 2 + for example fun(*bar) traverses all nodes - for example { 'foo': 2, 'bar': {}} + for example foo !~ 1 traverses all nodes - for example [/()\1/, ?#] + for example -42 traverses all nodes - for example case foo; in A[x:] then true; end + for example def m; class << self; class C; end; end; end traverses all nodes - for example bar def foo; self.each do end end + for example foo::C ||= raise(bar) rescue nil traverses all nodes - for example foo.(1) + for example fun(:foo => 1, &baz) traverses all nodes - for example f{ |a, *s, &b| } + for example case foo; in *x, y, z then nil; end traverses all nodes - for example foo.C += raise bar rescue nil + for example f{ |*r, p, &b| } traverses all nodes - for example case foo; in a:, b: then true; end + for example %I[#@1] traverses all nodes - for example !(a, b = foo) + for example case foo; in "#{ %q{a} }": then true; end traverses all nodes - for example begin end + for example a b{c d}, 1.0 do end traverses all nodes - for example { 1 => 2 } + for example <<-"HERE" +#@1 +HERE traverses all nodes - for example %i{a\ -b} + for example redo traverses all nodes - for example foo <= 1 + for example def f &b; end traverses all nodes - for example `a\ -b` + for example -> a: { } traverses all nodes - for example { foo: 2, **bar } + for example case foo; in [x, y, *] then true; end traverses all nodes - for example def f ((a, *)); end + for example f{ | | } traverses all nodes - for example p :foo, {proc do end => proc do end, b: proc do end} + for example case foo; in "#{ 'a' }": then true; end traverses all nodes - for example p :foo, {"a": proc do end, b: proc do end} + for example foo >> 1 traverses all nodes - for example def _5; end + for example def f o=1, *r, p, &b; end traverses all nodes - for example m { |**nil| } + for example f{ |**baz, &b| } traverses all nodes - for example foo % 1 + for example a b(c(d)), 1.0r do end traverses all nodes - for example f{ |o=1, *r, p, &b| } + for example if (bar; a, b = foo); end traverses all nodes - for example var = 10; var + for example [1, 2] traverses all nodes - for example foo.a += 1 + for example while class Foo; tap do end; end; break; end traverses all nodes - for example foo[0] += raise bar rescue nil + for example if foo...bar; end traverses all nodes - for example p <<~`E` - x - #{foo} -E + for example <<-'HERE' +#@1 +HERE traverses all nodes - for example foo::a = 1 + for example 1 in [a]; a traverses all nodes for example <<-"HERE" -#@@1 +a\ +b HERE traverses all nodes - for example foo::fun (1) {} + for example module Foo; end traverses all nodes - for example a += 1 + for example 42i + traverses all nodes + for example a b{c d}, 1.0r do end + traverses all nodes + for example meth[] {} + traverses all nodes + for example let () { m(a) do; end } + traverses all nodes + for example m def x(); end; 1.tap do end + traverses all nodes + for example foo & 1 traverses all nodes for example proc {_1 = nil} traverses all nodes - for example foo.a = 1 + for example class A; _1; end traverses all nodes - for example def f (foo: 1, &b); end + for example case foo; in "#{ %q{a} }": 1 then true; end + traverses all nodes + for example foo = baz, *bar traverses all nodes for example f{ |a, o=1, &b| } traverses all nodes - for example case foo; in "#{ 'a' }": 1 then true; end + for example f{ |a, *s| } traverses all nodes - for example 42r + for example super foo, bar do end traverses all nodes - for example def String::foo; end + for example yield traverses all nodes - for example /(?bar)/ =~ 'bar'; match + for example %s{#@@1} traverses all nodes - for example case foo; in {} then true; end + for example case foo; in 1; end traverses all nodes - for example false ? raise do end : tap do end + for example :'a\ +b' traverses all nodes - for example foo | 1 + for example f{ |o=1, p, &b| } traverses all nodes - for example -2.0 ** 10 + for example class Foo end traverses all nodes - for example case foo; in [x,] then nil; end + for example %I[#@@1] traverses all nodes - for example case foo; in "#{ %Q{a} }": 1 then true; end + for example foo.m += raise(bar) rescue nil traverses all nodes - for example foo ? 1 : 2 + for example foo[1, 2] = 3 traverses all nodes - for example nil + for example case foo; in 1, "a", [], {} then nil; end traverses all nodes - for example %{#@1} + for example a b{c d}, "x" do end traverses all nodes - for example %{#@@1} + for example while foo do meth end traverses all nodes - for example if foo; bar; else baz; end + for example Bar::Foo = 10 traverses all nodes - for example if (a, b = foo); end + for example fun (1) {} traverses all nodes - for example while def foo; tap do end; end; break; end + for example :'#@1' traverses all nodes - for example p :foo, {** proc do end, b: proc do end} + for example foo.fun bar traverses all nodes - for example def foo() a:b end + for example %x{#@1} traverses all nodes - for example a += b += raise :x + for example def f a, *r, p, &b; end traverses all nodes - for example fun (f bar) + for example bar if foo traverses all nodes - for example fun! + for example def f ((a, a1)); end traverses all nodes - for example p <<~E - x - \ y -E + for example f{ |a, *s, &b| } traverses all nodes - for example 42.1r + for example p :foo, {:a => proc do end, b: proc do end} traverses all nodes - for example a, *b, c = bar + for example /source/im traverses all nodes - for example return foo + for example def self.m; _1; end traverses all nodes - for example a b{c d}, "x" do end + for example +42 traverses all nodes - for example while not (true) do end + for example foo += raise bar rescue nil traverses all nodes - for example a b{c(d)}, 1.0r do end + for example "foo#{bar}baz" traverses all nodes - for example def m; class << self; class C; end; end; end + for example module Bar::Foo; end traverses all nodes - for example case foo; when 1, *baz; bar; when *foo; end + for example f(a ? "a":1) traverses all nodes - for example meth (-1.3).abs + for example foo or bar traverses all nodes - for example ...100 + for example { 1 => 2, :foo => "bar" } traverses all nodes - for example f{ |a, c| } + for example %W[#@1] traverses all nodes - for example foo && bar + for example m a + b do end traverses all nodes - for example foo = meth rescue bar + for example a&.b = 1 traverses all nodes -RuboCop::AST::LambdaNode - #method_name - is expected to eq :lambda - #arguments - is expected to eq 2 - #receiver - is expected to be nil - -RuboCop::AST::DefNode - #bang_method? - with a predicate method - is expected not to be bang method - with a bang method - is expected to be bang method - with a regular method - is expected not to be bang method - #first_argument - with a single rest argument - is expected to be restarg type - with no arguments - is expected to be nil - with multiple regular arguments - is expected to be arg type - with a single regular argument - is expected to be arg type - with multiple mixed arguments - is expected to be arg type - with a single keyword argument - is expected to be kwoptarg type - #block_argument? - with mixed arguments - is expected to be block argument - with regular arguments - is expected not to be block argument - with no arguments - is expected not to be block argument - with a block argument - is expected to be block argument - #predicate_method? - with a bang method - is expected not to be predicate method - with a predicate method - is expected to be predicate method - with a regular method - is expected not to be predicate method - #last_argument - with a single rest argument - is expected to be restarg type - with multiple regular arguments - is expected to be arg type - with a single keyword argument - is expected to be kwoptarg type - with multiple mixed arguments - is expected to be restarg type - with no arguments - is expected to be nil - with a single regular argument - is expected to be arg type +RuboCop::AST::AndNode + #logical_operator? + with a logical and node + is expected to be logical operator + with a semantic and node + is expected not to be logical operator .new - with a defs node - is expected to be a kind of RuboCop::AST::DefNode - with a def node - is expected to be a kind of RuboCop::AST::DefNode - #const_receiver? - with an instance method definition - is expected not to be const receiver - with a class method definition - is expected not to be const receiver - with a singleton method definition - is expected to be const receiver - #receiver - with an instance method definition - is expected to be nil - with a singleton method definition - is expected to be const type - with a class method definition - is expected to be self type - #arguments? - with no arguments - is expected not to be arguments - with a single keyword argument - is expected to be arguments - with multiple regular arguments - is expected to be arguments - with multiple mixed arguments - is expected to be arguments - with a single rest argument - is expected to be arguments - with a single regular argument - is expected to be arguments - #method? - when message matches - when argument is a string - is expected to be method "bar" - when argument is a symbol - is expected to be method :bar - when message does not match - when argument is a string - is expected not to be method "foo" - when argument is a symbol - is expected not to be method :foo - #self_receiver? - with an instance method definition - is expected not to be self receiver - with a class method definition - is expected to be self receiver - with a singleton method definition - is expected not to be self receiver - #method_name - with a setter method - is expected to eq :foo= - with a unary method - is expected to eq :-@ - with a plain method - is expected to eq :foo - with an operator method - is expected to eq :== - when using Ruby 2.7 or newer - #argument_forwarding? - is expected to be argument forwarding - #endless? - with standard method definition - is expected not to be endless - with endless method definition - is expected to be endless - #rest_argument? - with mixed arguments - is expected to be rest argument - with no arguments - is expected not to be rest argument - with a rest argument - is expected to be rest argument - with regular arguments - is expected not to be rest argument - #assignment_method? - with a comparison method - is expected not to be assignment method - with a regular method - is expected not to be assignment method - with an assignment method - is expected to be assignment method - with a bracket assignment method - is expected to be assignment method - #comparison_method? - with a regular method - is expected not to be comparison method - with a comparison method - is expected to be comparison method - #camel_case_method? - with a camel case method - is expected to be camel case method - with a regular method - is expected not to be camel case method - #void_context? - with a comparison method - is expected not to be void context - with an initializer method - is expected to be void context - with a regular assignment method - is expected to be void context - with a regular method - is expected not to be void context - with a bracket assignment method - is expected to be void context - #body - with no body - is expected to be nil - with a multi-expression body - is expected to be begin type - with a single expression body - is expected to be send type - #operator_method? - with a binary operator method - is expected to be operator method - with a setter method - is expected not to be operator method - with a regular method - is expected not to be operator method - with a unary operator method - is expected to be operator method - #arguments - with multiple mixed arguments - is expected to eq 2 - with a single rest argument - is expected to eq 1 - with argument forwarding - is expected to eq 1 - with a single regular argument - is expected to eq 1 - with multiple regular arguments - is expected to eq 2 - with no arguments - is expected to be empty - -RuboCop::AST::ReturnNode - behaves like wrapped arguments node - .new - with arguments - is expected to be a kind of RuboCop::AST::ReturnNode - without arguments - is expected to be a kind of RuboCop::AST::ReturnNode - #arguments - with multiple literal arguments - is expected to eq 2 - with no arguments - is expected to be empty - with a single argument and braces - is expected to eq 1 - with a single splat argument - is expected to eq 1 - with a single argument - is expected to eq 1 - with no arguments and braces - is expected to be empty + with a semantic and node + is expected to be a kind of RuboCop::AST::AndNode + with a logical and node + is expected to be a kind of RuboCop::AST::AndNode + #operator + with a semantic and node + is expected to eq "and" + with a logical and node + is expected to eq "&&" + #alternate_operator + with a semantic and node + is expected to eq "&&" + with a logical and node + is expected to eq "and" + #inverse_operator + with a logical and node + is expected to eq "||" + with a semantic and node + is expected to eq "or" + #rhs + with a logical and node + is expected to be int type + with a semantic and node + is expected to be int type + #semantic_operator? + with a semantic and node + is expected to be semantic operator + with a logical and node + is expected not to be semantic operator + #lhs + with a semantic and node + is expected to be sym type + with a logical and node + is expected to be sym type -RuboCop::AST::NodePattern - predicates - with a named argument - for which the predicate is true - is expected to match code s(:send, - s(:int, 1), :+, - s(:int, 2)) and {:param=>1} - when not given - raises an error - for which the predicate is false - behaves like nonmatching - doesn't match - with extra arguments - raises an error - with one extra argument - for which the predicate is true - is expected to match code s(:send, - s(:int, 1), :+, - s(:int, 2)) and 1 - for which the predicate is false - behaves like nonmatching - doesn't match - when negated - is expected to match code s(:int, 1) and :inc - applied to an integer for which the predicate is false - behaves like nonmatching - doesn't match - applied to an integer for which the predicate is true - is expected to match code s(:int, 1) and :inc - at head position of a sequence - is expected to match code s(:int, 1) and :inc - with a constant argument - for which the predicate is false - behaves like nonmatching - doesn't match - for which the predicate is true - is expected to match code s(:int, 1), :+, and s(:int, 2) - with an expression argument - for which the predicate is false - behaves like nonmatching - doesn't match - for which the predicate is true - is expected to match code s(:int, 2), :+, and s(:float, 2.0) - in root position - is expected to match code s(:int, 1) and :inc - with name containing a numeral - is expected to match code s(:int, 1) and :inc - with multiple arguments - for which the predicate is false - behaves like nonmatching - doesn't match - for which the predicate is true - is expected to match code s(:str, "c"), "a", and "d" - when captured - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - when in last-child position, but all children have already been matched - behaves like nonmatching - doesn't match - commas - with commas randomly strewn around - behaves like invalid - is invalid - regexp - matches symbols or strings - bare node type - #dup - is expected to match code s(:send, nil, :obj) and :method - yaml compatibility - is expected to match code s(:send, nil, :obj) and :method - on a node with a different type - behaves like nonmatching - doesn't match - #== - returns true iff the patterns are similar - #pattern - returns the pattern - on a node with the same type - is expected to match code s(:send, nil, :obj) and :method - marshal compatibility - is expected to match code s(:send, nil, :obj) and :method - #to_s - is instructive - on a node with a matching, hyphenated type - is expected to match code s(:lvasgn, :a), :+, and s(:int, 1) - funcalls - with one argument - is expected to match code s(:str, "foo") and "foo" - with multiple arguments - is expected to match code s(:str, "c"), "a", and "d" - without extra arguments - is expected to match code :a and s(:int, 1) - captures within union - with a different number of captures in each branch - behaves like invalid - is invalid - within nested sequences - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - on simple subpatterns - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with complex nesting - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - nil - nil literals - is expected to match code - against a node pattern (bug #5470) - behaves like nonmatching - doesn't match - nil value in AST - behaves like nonmatching - doesn't match - nil value in AST, use nil? method - is expected to match code nil and :foo - .descend - yields all children depth first - yields the given argument if it is not a Node - simple sequence - on a node with the same type and non-matching children - with non-matching selector - behaves like nonmatching - doesn't match - with non-matching receiver type - behaves like nonmatching - doesn't match - on a node with a different type - behaves like nonmatching - doesn't match - on a node with the same type and matching children - is expected to match code s(:int, 1), :+, and s(:int, 1) - on a node with too many children - behaves like nonmatching - doesn't match - with a nested sequence in non-head position - is expected to match code s(:send, - s(:send, nil, :obj), :a) and :b - with a nested sequence in head position - behaves like invalid - is invalid - wildcards - named wildcards - in head position of a sequence - is expected to match code s(:int, 1), :+, and s(:send, nil, :a) - within a sequence - with values which cannot be unified - behaves like nonmatching - doesn't match - with values which can be unified - is expected to match code s(:int, 5), :+, and s(:int, 5) - unifying the node type with an argument - is expected to match code s(:send, nil, :obj) and :send - at the root level - is expected to match code s(:sclass, - s(:self), - s(:def, :something, - s(:args), - s(:int, 1))) and :freeze - within a sequence with other patterns intervening - is expected to match code :@abc and s(:int, 22) - within a union - confined to the union - with partial unification - matching the free branch - is expected to match code s(:int, 2) and s(:int, 1) - that can not be unified - behaves like nonmatching - doesn't match - matching the unified branch - is expected to match code s(:int, 5) and s(:int, 5) - without unification - is expected to match code s(:int, 2) and s(:int, 1) - with a preceding unifying constraint - that can not be unified - behaves like nonmatching - doesn't match - matching a branch - is expected to match code s(:int, 2) and s(:array, - s(:int, 2), - s(:int, 1)) - with a succeeding unifying constraint - with all branches with the wildcard - matching another branch - is expected to match code s(:array, - s(:int, 2), - s(:int, 1)) and s(:int, 2) - matching the first branch - is expected to match code s(:array, - s(:int, 1), - s(:int, 2)) and s(:int, 2) - that can not be unified - behaves like nonmatching - doesn't match - with branches without the wildcard - encountered first - behaves like invalid - is invalid - encountered after - behaves like invalid - is invalid - unnamed wildcards - in head position of a sequence - is expected to match code s(:int, 1), :+, and s(:send, nil, :a) - at the root level - is expected to match code s(:sclass, - s(:self), - s(:def, :something, - s(:args), - s(:int, 1))) and :freeze - within a sequence with other patterns intervening - is expected to match code :@abc and s(:int, 22) - negated - behaves like nonmatching - doesn't match - within a sequence - is expected to match code nil and :Const - bad syntax - with doubled ellipsis - is expected to match code "foo" - with negated ellipsis - behaves like invalid - is invalid - with variadic unions where not supported - behaves like invalid - is invalid - with unmatched closing curly - behaves like invalid - is invalid - with leading comma in arg list - behaves like invalid - is invalid - with negated closing curly - behaves like invalid - is invalid - with unsupported subsequence in seq head within union - behaves like invalid - is invalid - with empty union subsequence in seq head - behaves like invalid - is invalid - with unmatched closing paren - behaves like invalid - is invalid - with unmatched opening paren - behaves like invalid - is invalid - with empty union - behaves like invalid - is invalid - with negated closing paren - behaves like invalid - is invalid - with empty intersection - behaves like invalid - is invalid - with doubled comma in arg list - behaves like invalid - is invalid - with unmatched opening curly - behaves like invalid - is invalid - with unmatched opening paren and `...` - behaves like invalid - is invalid - with empty parentheses - behaves like invalid - is invalid - caret (ascend) - used with a node type - which doesn't match - behaves like nonmatching - doesn't match - which matches - is expected to match code 1 - using unification to match self within parent - with self in the wrong position - behaves like nonmatching - doesn't match - with self in the right position - is expected to match code 2 - repeated twice - is expected to match code 1 - inside a union - is expected to match code "abc" - inside an intersection - is expected to match code 1 - within sequence - in head - is expected to match code 1 - of a sequence - is expected to match code 1 - not in head - is expected to match code s(:int, 1) and :inc - of a sequence - is expected to match code s(:int, 1) and :inc - descend - with an immediate match - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - without match - behaves like nonmatching - doesn't match - with a literal match - is expected to match code s(:int, 1) and s(:array, - s(:array, - s(:int, 2), - s(:int, 3), - s(:array, - s(:array, - s(:int, 5)))), - s(:int, 4)) - nested - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a match multiple levels, depth first - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - sequence with trailing ... - on a node with fewer children, with a wildcard preceding - behaves like nonmatching - doesn't match - on a node with non-matching children - behaves like nonmatching - doesn't match - on a node with the same type and exact number of children - is expected to match code s(:int, 1) and :blah - on a node with the same type and more children - with 1 child more - is expected to match code s(:int, 1), :blah, and s(:int, 1) - with 2 children more - is expected to match code s(:int, 1), :blah, s(:int, 1), and s(:sym, :something) - on a node with the same type and fewer children - behaves like nonmatching - doesn't match - on a node with a different type - behaves like nonmatching - doesn't match - repeated - using + - with zero match - behaves like nonmatching - doesn't match - with matching children - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - behaves like repeated pattern - at beginning of sequence - behaves like invalid - is invalid - with an ellipsis in the same sequence - is expected to match code "[:hello, 1, 2, 3]" - with one match - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - using * - without capture - is expected to match code s(:sym, :hello), s(:int, 1), s(:int, 2), and s(:int, 3) - behaves like repeated pattern - at beginning of sequence - behaves like invalid - is invalid - with one match - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with an ellipsis in the same sequence - is expected to match code "[:hello, 1, 2, 3]" - with no match - behaves like nonmatching - doesn't match - nested with multiple subcaptures - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with zero match - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with multiple subcaptures - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with matching children - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - using ? - behaves like repeated pattern - with an ellipsis in the same sequence - is expected to match code "[:hello, 1, 2, 3]" - at beginning of sequence - behaves like invalid - is invalid - with one match - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with zero match - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with too many matching children - behaves like nonmatching - doesn't match - comments - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - captures on a wildcard - in head position in a sequence against nil (bug #5470) - behaves like nonmatching - doesn't match - in non-head position in a sequence - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - at the root level - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - in head position in a sequence against literal (bug #5470) - behaves like nonmatching - doesn't match - in a nested sequence - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - in head position in a sequence - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - nested in any child - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - literals - symbol literals - is expected to match code :foo - single quoted string literals - is expected to match code "foo" - positive float literals - is expected to match code 1.0 - negative float literals - is expected to match code -2.5 - double quoted string literals - is expected to match code "foo" - negative integer literals - is expected to match code -100 - bare literal - on a matching literal - is expected to match code :bar - on a node - behaves like nonmatching - doesn't match - node type - for a child - on a child with the same type - is expected to match code s(:send, nil, :foo) and :bar - on a child with a different type - behaves like nonmatching - doesn't match - on a child litteral - behaves like nonmatching - doesn't match - in seq head - on a node with the same type - is expected to match code s(:ivar, :@ivar), :+, and s(:int, 2) - on a child with a different type - behaves like nonmatching - doesn't match - unions - nested inside a sequence - is expected to match code s(:const, nil, :Const) and :method - at the top level - containing mixed node and literals - is expected to match code nil and :obj - containing symbol literals - when the AST has a matching symbol - is expected to match code s(:send, nil, :obj) and :b - when the AST does not have a matching symbol - behaves like nonmatching - doesn't match - containing multiple [] - on a node which meets all requirements of the first [] - is expected to match code 3 - on a node which meets all requirements of the second [] - is expected to match code 2.4 - on a node which meets some requirements but not all - behaves like nonmatching - doesn't match - containing string literals - is expected to match code s(:str, "a") and :upcase - containing integer literals - is expected to match code s(:int, 10) and :abs - with a nested sequence - is expected to match code s(:const, nil, :Const) and :method - variadic - with variadic terms - works for cases with variadic terms before and after union - works for cases with variadic terms after union - works for cases with fixed arity before and after union - with fixed terms - works for cases with variadic terms before and after union - works for cases with fixed arity before and after union - works for cases with variadic terms after union - multiple - works for complex cases - params - when inside a union, with a nonmatching value - behaves like nonmatching - doesn't match - when preceded by $... - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - when preceded by ... - is expected to match code s(:send, - s(:int, 1), :+, - s(:int, 10)) and s(:int, 10) - when inside an intersection - is expected to match code s(:int, 20), 10, and 20 - when negated, with a matching value - behaves like nonmatching - doesn't match - when inside a union, with a matching value - is expected to match code s(:int, 10) and 10 - when negated, with a nonmatching value - is expected to match code s(:const, - s(:const, nil, :Namespace), :B) and :A - without explicit number - is expected to match code s(:const, - s(:const, nil, :Namespace), :A), :A, and s(:const, nil, :Namespace) - when captured - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - param number zero - in a position which matches original target node - is expected to match code 1 - in a position which does not match original target node - behaves like nonmatching - doesn't match - as named parameters - when provided as argument to match - is expected to match code s(:int, 10) and {:foo=>#} - when not provided - raises an ArgumentError - when extra are provided - raises an ArgumentError - in a nested sequence - is expected to match code s(:send, - s(:send, - s(:int, 5), :dec), :inc), :inc, and :dec - in root position - is expected to match code s(:int, 10) and s(:int, 10) - in root position - is expected to match code s(:int, 10) and # - captures on ... - with a remaining [] at the end - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a remaining sequence at the end - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a remaining wildcard at the end - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with a remaining literal at the end - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a remaining capture at the end - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with no remaining pattern at the end - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - at the very beginning of a sequence - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a remaining node type at the end - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - after a child - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with remaining patterns at the end - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with a remaining set at the end - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - negation - on a symbol - with a non-matching symbol - is expected to match code s(:send, nil, :obj) and :xyz - with a non-matching symbol, but too many children - behaves like nonmatching - doesn't match - with a matching symbol - behaves like nonmatching - doesn't match - on square brackets - with a node which meets only 1 requirement of [] - is expected to match code 1 - with a node which meets all requirements of [] - behaves like nonmatching - doesn't match - on a sequence - with a node with non-matching children - is expected to match code :@b and s(:int, 1) - with a node of different type - is expected to match code :@@a and s(:int, 1) - with a matching node - behaves like nonmatching - doesn't match - on a string - with a non-matching symbol - is expected to match code s(:str, "bar") and :upcase - with a matching string - behaves like nonmatching - doesn't match - on a set - with a matching value - behaves like nonmatching - doesn't match - with a non-matching value - is expected to match code :@a and s(:int, 3) - when nested in complex ways - with (send str :+ (send str :to_i)) - is expected to match code s(:str, "abc"), :+, and s(:send, - s(:str, "1"), :to_i) - with (send int :- int) - is expected to match code s(:int, 1), :-, and s(:int, 1) - with (send str :<< str) - behaves like nonmatching - doesn't match - ellipsis - with [] at the end, but no remaining child to match it - behaves like nonmatching - doesn't match - with a wildcard at the end, but no remaining child to match it - behaves like nonmatching - doesn't match - at the very beginning of a sequence - is expected to match code s(:int, 10), :*, and s(:int, 1) - preceding multiple captures - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with a nodetype at the end, but no remaining child to match it - behaves like nonmatching - doesn't match - with a nested sequence at the end, but no remaining child - behaves like nonmatching - doesn't match - with a set at the end, but no remaining child to match it - behaves like nonmatching - doesn't match - preceding a capture - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - captures which also perform a match - when nested - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - on a sequence - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - on [] - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - on a set - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - on a node type - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - on a literal - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - in any order - with a captured ellipsis - matching non sequential children - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - nested - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - matching all children - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - captured - without ellipsis - behaves like single capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - doubled - separated by fixed argument - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - separated by an ellipsis - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - with an ellipsis - behaves like single capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - invalid - doubled with ellipsis - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - with an ellipsis inside and outside - behaves like multiple capture - yields captured value(s) and returns true if there is a block - returns captured values if there is no block - doubled with ellipsis in wrong order - behaves like nonmatching - doesn't match - containing ellipsis not at the end - behaves like invalid - is invalid - nested - behaves like invalid - is invalid - at the beginning of a sequence - behaves like invalid - is invalid - without ellipsis - with too many children - behaves like nonmatching - doesn't match - with too few children - behaves like nonmatching - doesn't match - with matching children - behaves like multiple capture - returns captured values if there is no block - yields captured value(s) and returns true if there is a block - macros - with a pattern with a namespaced call - is expected to match code :hello - when the value is not in the set - behaves like nonmatching - doesn't match - with a pattern with captures - def_node_matcher - when called on matching code - is expected to eq :hello - when called on non-matching code - behaves like nonmatching - doesn't match - when it errors - raises an error with the right location - def_node_search - without a predicate name - when called on matching code - returns an enumerator yielding the captures - when the pattern contains keyword_params - returns an enumerator yielding the captures - when helper is called with default keyword_params - is overridden when calling the matcher - and no value is given to the matcher - uses the defaults - some defaults are not params - raises an error - when called on non-matching code - returns an enumerator yielding nothing - when it errors - raises an error with the right location - with a predicate name - when it errors - raises an error with the right location - when called on non-matching code - behaves like nonmatching - doesn't match - when called on matching code - is expected to match code nil, :foo, s(:sym, :hello), and s(:sym, :world) - with a pattern without captures - def_node_matcher - returns the method name - when called on matching code - is expected to match code :hello - when called on non-matching code - behaves like nonmatching - doesn't match - when it errors - raises an error with the right location - def_node_search - returns the method name - without a predicate name - when called on non-matching code - returns an enumerator yielding nothing - when it errors - raises an error with the right location - when called on matching code - returns an enumerator yielding the matches - with a predicate name - when it errors - raises an error with the right location - when called on matching code - is expected to match code nil, :foo, s(:sym, :hello), and s(:sym, :world) - when called on non-matching code - behaves like nonmatching - doesn't match - with a pattern with a constant - is expected to match code :hello - when the value is not in the set - behaves like nonmatching - doesn't match +RuboCop::AST::ArgsNode + #argument_list + is expected to eq [s(:arg, :a), s(:optarg, :b, + s(:int, 42)), s(:arg, :c), s(:restarg, :d), s(:kwarg, :e), s(:kwoptarg, :f, + s(:int, 42)), s(:kwrestarg, :g), s(:blockarg, :h), s(:shadowarg, :i)] + when using Ruby 2.7 or newer + with argument forwarding + is expected to eq [s(:forward_arg)] + .new + with a method definition + is expected to be a kind of RuboCop::AST::ArgsNode + with a lambda literal + is expected to be a kind of RuboCop::AST::ArgsNode + with a block + is expected to be a kind of RuboCop::AST::ArgsNode + #empty_and_without_delimiters? + with arguments + with a method definition + is expected to equal false + with a lambda literal + is expected to equal false + with empty arguments + with a method definition + is expected to equal true + with a block + is expected to equal true + with a lambda literal + is expected to equal true + with delimiters + with a block + is expected to equal false + with a method definition + is expected to equal false + with a lambda literal + is expected to equal false RuboCop::AST::IfNode - #else_branch + #if_branch + with a ternary operator + is expected to be sym type with an if statement - is expected to be int type + is expected to be sym type with an unless statement - is expected to be int type + is expected to be sym type + #each_branch + when not passed a block + is expected to be a kind of Enumerator + when passed a block + yields all the branches + #elsif_conditional? + with nested conditionals in else clause + is expected not to be elsif conditional + with nested conditionals in if clause + is expected not to be elsif conditional + with one elsif conditional + is expected to be elsif conditional + with multiple elsif conditionals + is expected to be elsif conditional + with nested ternary operators + when nested in the truthy branch + is expected not to be elsif conditional + when nested in the falsey branch + is expected not to be elsif conditional + #if? + with an unless statement + is expected not to be if with a ternary operator - is expected to be int type + is expected not to be if + with an if statement + is expected to be if + .new + with a regular if statement + is expected to be a kind of RuboCop::AST::IfNode + with a ternary operator + is expected to be a kind of RuboCop::AST::IfNode + with a modifier statement + is expected to be a kind of RuboCop::AST::IfNode + #unless? + with an unless statement + is expected to be unless + with a ternary operator + is expected not to be unless + with an if statement + is expected not to be unless #modifier_form? - with a modifier unless statement + with a modifier if statement is expected to be modifier form with a ternary operator is expected not to be modifier form - with a non-modifier unless statement - is expected not to be modifier form with a non-modifier if statement is expected not to be modifier form - with a modifier if statement + with a modifier unless statement is expected to be modifier form + with a non-modifier unless statement + is expected not to be modifier form #keyword - with an if statement - is expected to eq "if" with a ternary operator is expected to eq "" with an unless statement is expected to eq "unless" + with an if statement + is expected to eq "if" #elsif? without an elsif statement is expected not to be elsif @@ -5335,1201 +6050,522 @@ is expected not to be elsif with an elsif statement is expected to be elsif - #else? - with an elsif statement - is expected to be else - without an else statement - is expected not to be elsif - #unless? - with a ternary operator - is expected not to be unless + #else_branch with an unless statement - is expected to be unless - with an if statement - is expected not to be unless - #if? + is expected to be int type with an if statement - is expected to be if - with an unless statement - is expected not to be if + is expected to be int type with a ternary operator - is expected not to be if - .new - with a regular if statement - is expected to be a kind of RuboCop::AST::IfNode + is expected to be int type + #branches with a ternary operator - is expected to be a kind of RuboCop::AST::IfNode - with a modifier statement - is expected to be a kind of RuboCop::AST::IfNode + is expected to all be literal + is expected to eq 2 + with an unless statement + is expected to eq 1 + is expected to all be literal + with an elsif statement + is expected to eq 3 + is expected to all be literal + with an else statement + is expected to eq 2 + is expected to all be literal + with an if statement + is expected to all be literal + is expected to eq 1 #nested_conditional? - with nested conditionals in elsif clause - is expected to be nested conditional - with nested conditionals in if clause - is expected to be nested conditional with nested ternary operators when nested in the truthy branch is expected to be nested conditional when nested in the falsey branch is expected to be nested conditional + with nested conditionals in if clause + is expected to be nested conditional with no nested conditionals is expected not to be nested conditional - with nested conditionals in else clause + with nested conditionals in elsif clause is expected to be nested conditional - #elsif_conditional? with nested conditionals in else clause - is expected not to be elsif conditional - with nested ternary operators - when nested in the falsey branch - is expected not to be elsif conditional - when nested in the truthy branch - is expected not to be elsif conditional - with multiple elsif conditionals - is expected to be elsif conditional - with one elsif conditional - is expected to be elsif conditional - with nested conditionals in if clause - is expected not to be elsif conditional - #each_branch - when passed a block - yields all the branches - when not passed a block - is expected to be a kind of Enumerator + is expected to be nested conditional #inverse_keyword? with a ternary operator is expected to eq "" - with an unless statement - is expected to eq "if" with an if statement is expected to eq "unless" + with an unless statement + is expected to eq "if" #ternary? - with a ternary operator - is expected to be ternary - with an if statement - is expected not to be ternary with an unless statement is expected not to be ternary - #if_branch with a ternary operator - is expected to be sym type + is expected to be ternary with an if statement - is expected to be sym type - with an unless statement - is expected to be sym type - #branches - with a ternary operator - is expected to eq 2 - is expected to all be literal - with an unless statement - is expected to eq 1 - is expected to all be literal + is expected not to be ternary + #else? with an elsif statement - is expected to eq 3 - is expected to all be literal - with an if statement - is expected to eq 1 - is expected to all be literal - with an else statement - is expected to eq 2 - is expected to all be literal + is expected to be else + without an else statement + is expected not to be elsif -RuboCop::AST::FloatNode - #sign? - explicit negative float - is expected to be sign - explicit positive float - is expected to be sign - .new - is expected to be a kind of RuboCop::AST::FloatNode - #value - is expected to eq 1.5 +RuboCop::AST::NodePattern::Parser + sequences + expands ... in sequence head deep inside unions + generates specialized nodes + parses function calls + parses simple sequences properly + parses capture vs repetition with correct priority + parses unions of literals as a set -RuboCop::AST::WhileNode - #loop_keyword? - with a statement while - is expected to be loop keyword - with a modifier while - is expected to be loop keyword +RuboCop::AST::ForNode .new - with a modifier while - is expected to be a kind of RuboCop::AST::WhileNode - with a statement while - is expected to be a kind of RuboCop::AST::WhileNode - #inverse_keyword - is expected to eq "until" + is expected to be a kind of RuboCop::AST::ForNode + #variable + is expected to be lvasgn type #do? with a do keyword is expected to be do without a do keyword is expected not to be do #keyword - is expected to eq "while" + is expected to eq "for" + #body + is expected to be sym type + #void_context? + without a do keyword + is expected to be void context + with a do keyword + is expected to be void context + #loop_keyword? + is expected to be loop keyword + #collection + is expected to be sym type #post_condition_loop? - with a modifier while - is expected to be post condition loop - with a statement while - is expected not to be post condition loop - -RuboCop::AST::OrAsgnNode - #expression - is expected to eq s(:send, nil, :value) - #operator - is expected to eq :"||" - .new - is expected to be a kind of RuboCop::AST::OrAsgnNode - #assignment_node - is expected to be a kind of RuboCop::AST::AsgnNode - #name - is expected to eq :var - -RuboCop::AST::AndAsgnNode - #name - is expected to eq :var - #operator - is expected to eq :"&&" - .new - is expected to be a kind of RuboCop::AST::AndAsgnNode - #expression - is expected to eq s(:send, nil, :value) - #assignment_node - is expected to be a kind of RuboCop::AST::AsgnNode - -RuboCop::AST::DstrNode - #value - with a multiline string - is expected to eq "this is a multiline string" - with interpolation - is expected to eq "foo \#{bar} baz" - with implicit concatenation - is expected to eq "foo bar baz" - -RuboCop::AST::NextNode - behaves like wrapped arguments node - #arguments - with no arguments and braces - is expected to be empty - with multiple literal arguments - is expected to eq 2 - with a single argument and braces - is expected to eq 1 - with a single splat argument - is expected to eq 1 - with a single argument - is expected to eq 1 - with no arguments - is expected to be empty - .new - with arguments - is expected to be a kind of RuboCop::AST::NextNode - without arguments - is expected to be a kind of RuboCop::AST::NextNode - -RuboCop::AST::SuperNode - #method_name - is expected to eq :super - #parenthesized? - with no arguments - when not using parentheses - is expected not to be parenthesized - when using parentheses - is expected to be parenthesized - with arguments - when using parentheses - is expected to be parenthesized - when not using parentheses - is expected not to be parenthesized - #operator_method? - is expected not to be operator method - #const_receiver? - is expected not to be const receiver - #method? - when message matches - when argument is a string - is expected to be method "super" - when argument is a symbol - is expected to be method :super - when message does not match - when argument is a string - is expected not to be method "foo" - when argument is a symbol - is expected not to be method :foo - .new - with a zsuper node - is expected to be a kind of RuboCop::AST::SuperNode - with a super node - is expected to be a kind of RuboCop::AST::SuperNode - #block_argument? - with a block argument - is expected to be block argument - with mixed arguments - is expected to be block argument - with no arguments - is expected not to be block argument - with regular arguments - is expected not to be block argument - #arguments - with a single literal argument - is expected to eq 1 - with no arguments - is expected to be empty - with multiple mixed arguments - is expected to eq 2 - with a single splat argument - is expected to eq 1 - with multiple literal arguments - is expected to eq 2 - #receiver - is expected to be nil - #block_node - with no block - is expected to be nil - with a block argument - is expected to be nil - with a block literal - is expected to be block type - #implicit_call? - is expected not to be implicit call - #predicate_method? - is expected not to be predicate method - #setter_method? - is expected not to be setter method - #command? - when argument is a string - is expected to be command "super" - when argument is a symbol - is expected to be command :super - #self_receiver? - is expected not to be self receiver - #first_argument - with a single splat argument - is expected to be splat type - with no arguments - is expected to be nil - with a single literal argument - is expected to be sym type - with multiple mixed arguments - is expected to be sym type - with multiple literal arguments - is expected to be sym type - #comparison_method? - is expected not to be comparison method - #last_argument - with a single literal argument - is expected to be sym type - with multiple literal arguments - is expected to be sym type - with a single splat argument - is expected to be splat type - with multiple mixed arguments - is expected to be splat type - with no arguments - is expected to be nil - #assignment_method? - is expected not to be assignment method - #dot? - is expected not to be dot - #block_literal? - with a block argument - is expected not to be block literal - with a block literal - is expected to be block literal - with no block - is expected not to be block literal - #splat_argument? - with regular arguments - is expected not to be splat argument - with a splat argument - is expected to be splat argument - with mixed arguments - is expected to be splat argument - with no arguments - is expected not to be splat argument - #camel_case_method? - is expected not to be camel case method - #arguments? - with multiple mixed arguments - is expected to be arguments - with multiple literal arguments - is expected to be arguments - with no arguments - is expected not to be arguments - with a single literal argument - is expected to be arguments - with a single splat argument - is expected to be arguments - #macro? - is expected not to be macro - #double_colon? - is expected not to be double colon - #bang_method? - is expected not to be bang method - -RuboCop::AST::HashNode - #keys - with a hash with symbol keys - is expected to eq 3 - is expected to all be sym type - with an empty hash - is expected to be empty - with a hash with string keys - is expected to all be str type - is expected to eq 2 - #pairs - with an empty hash - is expected to be empty - with a hash of literals - is expected to eq 3 - is expected to all be pair type - with a hash of variables - is expected to all be pair type - is expected to eq 2 - #empty? - with a hash containing a keyword splat - is expected not to be empty - with an empty hash - is expected to be empty - with a hash containing pairs - is expected not to be empty - #each_key - when passed a block - yields all the pairs - when not passed a block - is expected to be a kind of Enumerator - #values - with a hash with literal values - is expected to eq 3 - is expected to all be literal - with a hash with string keys - is expected to eq 2 - is expected to all be send type - with an empty hash - is expected to be empty - #braces? - as an argument with braces - is expected to be braces - with braces - is expected to be braces - as an argument with no braces - is expected not to be braces - .new - is expected to be a kind of RuboCop::AST::HashNode - #each_value - when not passed a block - is expected to be a kind of Enumerator - when passed a block - yields all the pairs - #mixed_delimiters? - when all pairs are using a colon delimiter - is expected not to be mixed delimiters - when pairs are using different delimiters - is expected to be mixed delimiters - when all pairs are using a hash rocket delimiter - is expected not to be mixed delimiters - #pairs_on_same_line? - with no pairs on the same line - is expected not to be pairs on same line - with all pairs on the same line - is expected to be pairs on same line - with some pairs on the same line - is expected to be pairs on same line - #each_pair - when passed a block - yields all the pairs - when not passed a block - is expected to be a kind of Enumerator - -RuboCop::AST::ProcessedSource - #last_token_of - accepts Node as an argument - returns last token for node - #blank? - with source with content - returns false - with source of no content - returns true - valid_syntax? - when the source itself is valid encoding but includes strange encoding literals that are accepted by MRI - returns true - when the source could not be parsed due to encoding error - returns false - when a line starts with an integer literal - tokenizes the source correctly - when the source is completely valid - returns true - when the source is invalid - returns false - when the source is valid but has some warning diagnostics - returns true - #following_line - returns source of line after token - with heavily commented source - #comment_at_line - returns nil if line has no comment - returns the comment at the given line number - #contains_comment? - provided a multiline source_range with at least one line with comment - is expected to equal true - provided source_range on comment line - is expected to equal true - provided source_range on line with comment - is expected to equal true - provided source_range on line without comment - is expected to equal false - #each_comment - yields all comments - #each_comment_in_lines - yields the comments - #comments_before_line - returns comments on or before given line - #find_comment - yields correct comment - yields nil when there is no match - #line_with_comment? - returns true for lines with comments - returns false for lines without comments - .from_file - raises a Errno::ENOENT when the file does not exist - when the file exists - returns an instance of ProcessedSource - sets the file path to the instance's #path - #lines - is an array - has same number of elements as line count - contains lines as string without linefeed - #comments - is an array of comments - when the source is invalid - returns [] - #preceding_line - returns source of line before token - #buffer - is a source buffer - #ast - is the root node of AST - #path - is the path passed to .new - #file_path - returns file path - #parser_error - when the source was properly parsed - is nil - when the source could not be parsed due to encoding error - returns the error - when the source lacks encoding comment and is really utf-8 encoded but has been read as US-ASCII - is nil - #tokens - has an array of tokens - #start_with? - with present source - returns false when passed string that does not start source - returns true when passed string that starts source - with blank source - returns false - #[] - when a range is passed - returns the array of lines - when an index is passed - returns the line - when start index and length are passed - returns the array of lines - token enumerables - #find_token - yields correct token - yields nil when there is no match - #each_token - yields all tokens - #tokens_within - returns tokens for node - accepts Node as an argument - when heredoc as argument is present - returns tokens for heredoc node - returns tokens for node before heredoc - returns tokens for node after heredoc - #first_token_of - accepts Node as an argument - returns first token for node + is expected not to be post condition loop RuboCop::AST::NodePattern::Lexer provides tokens via next_token when given node types and constants distinguishes them - when given a regexp /[abc]+\/()?/x - round trips when given a regexp /back\\slash/ round trips + when given a regexp /[abc]+\/()?/x + round trips with $type+ is parsed as `$ int + x` - when given a regexp ending with a backslash - does not lexes it properly when given arithmetic symbols is parsed as `:&` + when given a regexp ending with a backslash + does not lexes it properly when given a regexp /test/ round trips -RuboCop::AST::BlockNode - #argument_list - >= Ruby 2.7 - using numbered parameters - with skipped params - is expected to eq [:_1, :_2, :_3, :_4, :_5, :_6, :_7] - with sequential params - is expected to eq [:_1, :_2] - with no arguments - is expected to be empty - all argument types - is expected to eq [:a, :b, :c, :d, :e, :f, :g, :h, :i] - #lambda? - when block belongs to a stabby lambda - is expected to be lambda - when block belongs to a non-lambda method - is expected not to be lambda - when block belongs to a method lambda - is expected to be lambda - #single_line? - when block is on several lines - is expected not to be single line - when block is on a single line - is expected to be single line - #closing_delimiter - when enclosed in do-end keywords - is expected to eq "end" - when enclosed in braces - is expected to eq "}" - #keywords? - when enclosed in braces - is expected not to be keywords - when enclosed in do-end keywords - is expected to be keywords - #delimiters - when enclosed in braces - is expected to eq ["{", "}"] - when enclosed in do-end keywords - is expected to eq ["do", "end"] - #arguments - with no arguments - is expected to be empty - with a single splat argument - is expected to eq 1 - >= Ruby 2.7 - using numbered parameters - is expected to be empty - with multiple mixed arguments - is expected to eq 2 - with destructured arguments - is expected to eq 2 - with a single literal argument - is expected to eq 1 - #opening_delimiter - when enclosed in do-end keywords - is expected to eq "do" - when enclosed in braces - is expected to eq "{" - #multiline? - when block is on several lines - is expected to be multiline - when block is on a single line - is expected not to be multiline - #braces? - when enclosed in do-end keywords - is expected not to be braces - when enclosed in braces - is expected to be braces +RuboCop::AST::FloatNode + #sign? + explicit positive float + is expected to be sign + explicit negative float + is expected to be sign .new - is expected to be a kind of RuboCop::AST::BlockNode - #void_context? - when block method is each - is expected to be void context - when block method is tap - is expected to be void context - when block method is not each - is expected not to be void context - #arguments? - >= Ruby 2.7 - using numbered parameters - is expected not to be arguments - with a single argument - is expected to be arguments - with multiple mixed arguments - is expected to be arguments - with no arguments - is expected not to be arguments - with a single splat argument - is expected to be arguments - with destructuring arguments - is expected to be arguments - #receiver - with safe navigation operator call - is expected to eq "foo" - with dot operator call - is expected to eq "foo" + is expected to be a kind of RuboCop::AST::FloatNode + #value + is expected to eq 1.5 -RuboCop::AST::ArgsNode - #argument_list - is expected to eq [s(:arg, :a), s(:optarg, :b, - s(:int, 42)), s(:arg, :c), s(:restarg, :d), s(:kwarg, :e), s(:kwoptarg, :f, - s(:int, 42)), s(:kwrestarg, :g), s(:blockarg, :h), s(:shadowarg, :i)] - when using Ruby 2.7 or newer - with argument forwarding - is expected to eq [s(:forward_arg)] - .new - with a lambda literal - is expected to be a kind of RuboCop::AST::ArgsNode - with a method definition - is expected to be a kind of RuboCop::AST::ArgsNode - with a block - is expected to be a kind of RuboCop::AST::ArgsNode - #empty_and_without_delimiters? - with delimiters - with a lambda literal - is expected to equal false - with a method definition - is expected to equal false - with a block - is expected to equal false - with arguments - with a method definition - is expected to equal false - with a lambda literal - is expected to equal false - with empty arguments - with a block - is expected to equal true - with a method definition - is expected to equal true - with a lambda literal - is expected to equal true +RuboCop::AST::Token + #space_before + returns nil when there is not a space before token + returns truthy MatchData when there is a space before token + returns nil when it is on the first line + #to_s + returns string of token data + type predicates + #rescue_modifier? + returns false for non rescue modifier tokens + returns true for rescue modifier tokens + #left_bracket? + returns true for all left_bracket tokens + returns false for non left_bracket tokens + #regexp_dots? + returns true for regexp tokens + returns false for non comma tokens + #left_ref_bracket? + returns false for non left_ref_bracket tokens + returns true for left_ref_bracket tokens + #semicolon? + returns false for non semicolon tokens + returns true for semicolon tokens + #comment? + returns true for comment tokens + returns false for non comment tokens + #equals_sign? + returns true for equals sign tokens + returns false for non equals sign tokens + #comma? + returns false for non comma tokens + returns true for comma tokens + with braces & parens + #left_curly_brace? + returns false for non left block brace tokens + returns true for left block brace tokens + #right_parens? + returns false for non right parens tokens + returns true for right parens tokens + #left_parens? + returns false for non left parens tokens + returns true for left parens tokens + #right_curly_brace? + returns true for all right brace tokens + returns false for non right brace tokens + #left_brace? + returns true for left hash brace tokens + returns false for non left hash brace tokens + #left_brace? + returns true for right_bracket tokens + returns false for non right_bracket tokens + #new_line? + returns false for non new line tokens + returns true for new line tokens + #dot? + returns false for non dot tokens + returns true for dot tokens + #right_bracket? + returns false for non right_bracket tokens + returns true for all right_bracket tokens + #left_array_bracket? + returns true for left_array_bracket tokens + returns false for non left_array_bracket tokens + #end? + returns true for end tokens + returns false for non end tokens + #line + returns line of token + #column + returns index of first char in token range on that line + #begin_pos + returns index of first char in token range of entire source + #space_after + returns truthy MatchData when there is a space after token + returns nil when there is not a space after token + .from_parser_token + returns a #to_s useful for debugging + sets parser token's type to rubocop token's type + sets parser token's range to rubocop token's pos + sets parser token's text to rubocop token's text + #end_pos + returns index of last char in token range of entire source -RuboCop::AST::BreakNode - behaves like wrapped arguments node - .new - without arguments - is expected to be a kind of RuboCop::AST::BreakNode - with arguments - is expected to be a kind of RuboCop::AST::BreakNode - #arguments - with multiple literal arguments - is expected to eq 2 - with a single splat argument - is expected to eq 1 - with a single argument - is expected to eq 1 - with no arguments - is expected to be empty - with a single argument and braces - is expected to eq 1 - with no arguments and braces - is expected to be empty +RuboCop::AST::RescueNode + #else? + with an else statement + is expected to be else + without an else statement + is expected not to be else + #else_branch + without an else statement + is expected to be nil + with an else statement + is expected to be send type + #body + is expected to be send type + #resbody_branches + is expected to eq 2 + is expected to all be resbody type + #branches + when there is an else + returns all the bodies + with an empty else + returns all the bodies + when there is no else keyword + returns only then rescue bodies + .new + is expected to be a kind of RuboCop::AST::RescueNode -RuboCop::AST::DefinedNode +RuboCop::AST::OrAsgnNode + #operator + is expected to eq :"||" + #assignment_node + is expected to be a kind of RuboCop::AST::AsgnNode + #name + is expected to eq :var .new - with a defined? node - is expected to be a kind of RuboCop::AST::DefinedNode - #method_name - is expected to eq :defined? - #arguments - is expected to eq 1 - is expected to all be sym type - #receiver - is expected to be nil + is expected to be a kind of RuboCop::AST::OrAsgnNode + #expression + is expected to eq s(:send, nil, :value) -RuboCop::AST::OrNode +RuboCop::AST::EnsureNode + #body + is expected to be sym type .new - with a semantic or node - is expected to be a kind of RuboCop::AST::OrNode - with a logical or node - is expected to be a kind of RuboCop::AST::OrNode - #lhs - with a logical or node - is expected to be sym type - with a semantic or node - is expected to be sym type - #inverse_operator - with a logical or node - is expected to eq "&&" - with a semantic or node - is expected to eq "and" - #alternate_operator - with a logical or node - is expected to eq "or" - with a semantic or node - is expected to eq "||" - #operator - with a semantic or node - is expected to eq "or" - with a logical or node - is expected to eq "||" - #rhs - with a semantic or node - is expected to be int type - with a logical or node - is expected to be int type - #logical_operator? - with a semantic or node - is expected not to be logical operator - with a logical or node - is expected to be logical operator - #semantic_operator? - with a semantic or node - is expected to be semantic operator - with a logical or node - is expected not to be semantic operator + is expected to be a kind of RuboCop::AST::EnsureNode -RuboCop::AST::StrNode - #heredoc? - with a heredoc - is expected to be heredoc - with a normal string - is expected not to be heredoc - with a string with interpolation - is expected not to be heredoc - #character_literal? - with a normal string literal - is expected not to be character literal - with a character literal - is expected to be character literal - with a heredoc - is expected not to be character literal +RuboCop::AST::NodePattern::Sets + is expected to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC" + is expected not to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC_2" + is expected to eq "::RuboCop::AST::NodePattern::Sets::SET_1_2_3_ETC" + creates a constant with the right value + +RuboCop::AST::RegexpNode + #regopt + with an empty regexp + is expected to be regopt type + is expected to be empty + with an empty regexp with option + is expected to eq [:i, :x] + is expected to be regopt type + with a regexp with option + is expected to eq [:i, :m, :x] + is expected to be regopt type + with a multi-line regexp with option + is expected to be regopt type + is expected to eq [:i, :m, :x] + with a regexp without option + is expected to be regopt type + is expected to be empty + with a multi-line regexp without option + is expected to be regopt type + is expected to be empty + #to_regexp + with a multi-line regexp without option + is expected to eq / +.+ +/ + with a regexp with option + is expected to eq /.+/mix + with a regexp with an "o" option + is expected to eq "/abc/i" + with an empty regexp with option + is expected to eq //ix + with a multi-line regexp with option + is expected to eq / +.+ +/ix + with an empty regexp + is expected to eq // + with a regexp with an "n" option + is expected to eq "/abc/n" + with a regexp without option + is expected to eq /.+/ + with a regexp with an "u" option + is expected to eq "/abc/" + #percent_r_literal? + with %r/-delimiters + is expected to be percent r literal + with %r<-delimiters + is expected to be percent r literal + with multi-line %r{-delimiters + is expected to be percent r literal + with /-delimiters + is expected not to be percent r literal + with %r{-delimiters + is expected to be percent r literal + #multiline_mode? + with only m option + is expected to be multiline mode + with no options + is expected not to be multiline mode + with other options + is expected not to be multiline mode + with m and other options + is expected to be multiline mode + #no_encoding? + with n and other options + is expected to be no encoding + with only n option + is expected to be no encoding + with other options + is expected not to be no encoding + with no options + is expected not to be no encoding + #content + with an empty regexp + is expected to eq "" + with an empty regexp with option + is expected to eq "" + with a multi-line regexp with option + is expected to eq "\n.+\n" + with a regexp with option + is expected to eq ".+" + with a regexp without option + is expected to eq ".+" + with a multi-line regexp without option + is expected to eq "\n.+\n" + #single_interpolation? + with other options + is expected not to be single interpolation + with o and other options + is expected to be single interpolation + with no options + is expected not to be single interpolation + with only o option + is expected to be single interpolation + #ignore_case? + with i and other options + is expected to be ignore case + with other options + is expected not to be ignore case + with no options + is expected not to be ignore case + with only i option + is expected to be ignore case + #fixed_encoding? + with no options + is expected not to be fixed encoding + with other options + is expected not to be fixed encoding + with u and other options + is expected to be fixed encoding + with only u option + is expected to be fixed encoding + #interpolation? + with direct variable interpoation + is expected to be interpolation + with no interpolation returns false + is expected not to be interpolation + with regexp quote + is expected to be interpolation .new - with a string with interpolation - is expected to be a kind of RuboCop::AST::StrNode - with a heredoc - is expected to be a kind of RuboCop::AST::StrNode - with a normal string - is expected to be a kind of RuboCop::AST::StrNode + is expected to be a kind of RuboCop::AST::RegexpNode + #options + with a regexp with single option + is expected to eq 1 + with a regexp with multiple options + is expected to eq 3 + with a regexp without option + is expected to eq 0 + with a regexp with "o" option + is expected to eq 0 + with an empty regexp + is expected to eq 0 + #delimiters + with %r{-delimiters + is expected to eq ["{", "}"] + with multi-line %r{-delimiters + is expected to eq ["{", "}"] + with /-delimiters + is expected to eq ["/", "/"] + with %r<-delimiters + is expected to eq ["<", ">"] + with %r/-delimiters + is expected to eq ["/", "/"] + #extended? + with no options + is expected not to be extended + with other options + is expected not to be extended + with x and other options + is expected to be extended + with only x option + is expected to be extended + #slash_literal? + with %r{-delimiters + is expected not to be slash literal + with multi-line %r{-delimiters + is expected not to be slash literal + with /-delimiters + is expected to be slash literal + with %r<-delimiters + is expected not to be slash literal + with %r/-delimiters + is expected not to be slash literal + #delimiter? + with %r{-delimiters + is expected not to be delimiter "%" + is expected not to be delimiter "/" + is expected not to be delimiter "%r{" + is expected not to be delimiter "%r/" + is expected to be delimiter "{" + is expected to be delimiter "}" + is expected not to be delimiter "%r" + is expected not to be delimiter "r" + with %r<-delimiters + is expected not to be delimiter "/" + is expected not to be delimiter "}" + is expected to be delimiter "<" + is expected not to be delimiter "%r" + is expected not to be delimiter "%r{" + is expected not to be delimiter "%r<" + is expected not to be delimiter "%" + is expected not to be delimiter "{" + is expected not to be delimiter "r" + is expected to be delimiter ">" + is expected not to be delimiter "%r/" + with /-delimiters + is expected to be delimiter "/" + is expected not to be delimiter "{" + with multi-line %r{-delimiters + is expected to be delimiter "}" + is expected not to be delimiter "r" + is expected not to be delimiter "%r" + is expected to be delimiter "{" + is expected not to be delimiter "%" + is expected not to be delimiter "%r{" + is expected not to be delimiter "%r/" + is expected not to be delimiter "/" + with %r/-delimiters + is expected to be delimiter "/" + is expected not to be delimiter "%" + is expected not to be delimiter "r" + is expected not to be delimiter "%r" + is expected not to be delimiter "{" + is expected not to be delimiter "}" + is expected not to be delimiter "%r/" -RuboCop::AST::SymbolNode +RuboCop::AST::RangeNode .new - with a symbol node - is expected to be a kind of RuboCop::AST::SymbolNode - #value - is expected to eq :foo + with an inclusive range + is expected to be a kind of RuboCop::AST::RangeNode + is expected to be range type + with an infinite range + is expected to be range type + is expected to be a kind of RuboCop::AST::RangeNode + with a beignless range + is expected to be a kind of RuboCop::AST::RangeNode + is expected to be range type + with an exclusive range + is expected to be a kind of RuboCop::AST::RangeNode + is expected to be range type RuboCop::AST::ResbodyNode + #body + is expected to be sym type #exception_variable when an exception variable is not given is expected to be nil - for an explicit rescue - is expected to eq "ex" for an implicit rescue is expected to eq "ex" + for an explicit rescue + is expected to eq "ex" .new is expected to be a kind of RuboCop::AST::ResbodyNode - #branch_index - is expected to eq 2 - is expected to eq 1 - is expected to eq 0 - #body - is expected to be sym type #exceptions with a single exception is expected to all be const type is expected to eq 1 with multiple exceptions - is expected to eq 2 is expected to all be const type - without exception - is expected to eq 0 - -RuboCop::AST::AsgnNode - #expression - with a `lvasgn` node - is expected to eq s(:send, nil, :value) - with a `cvasgn` node - is expected to eq s(:send, nil, :value) - with a `ivasgn` node - is expected to eq s(:send, nil, :value) - with a `gvasgn` node - is expected to eq s(:send, nil, :value) - .new - with a `gvasgn` node - is expected to be a kind of RuboCop::AST::AsgnNode - with a `cvasgn` node - is expected to be a kind of RuboCop::AST::AsgnNode - with a `lvasgn` node - is expected to be a kind of RuboCop::AST::AsgnNode - with a `ivasgn` node - is expected to be a kind of RuboCop::AST::AsgnNode - #name - with a `lvasgn` node - is expected to eq :var - with a `ivasgn` node - is expected to eq :@var - with a `cvasgn` node - is expected to eq :@@var - with a `gvasgn` node - is expected to eq :$var - -RuboCop::AST::InPatternNode - when using Ruby 2.7 or newer - #body - without a then keyword - is expected to be array type - with a then keyword - is expected to be sym type - #pattern - with a variable pattern - is expected to be match var type - with an alternative pattern - is expected to be match alt type - with a value pattern - is expected to be int type - with a hash pattern - is expected to be hash pattern type - with an array pattern - is expected to be array pattern type - with an as pattern - is expected to be match as type - with a pin operator - is expected to be pin type - #then? - without a then keyword - is expected not to be then - with a then keyword - is expected to be then - #branch_index is expected to eq 2 + without exception is expected to eq 0 - is expected to eq 1 - .new - is expected to be a kind of RuboCop::AST::InPatternNode - -RuboCop::AST::RescueNode - #else_branch - with an else statement - is expected to be send type - without an else statement - is expected to be nil - #body - is expected to be send type - #else? - with an else statement - is expected to be else - without an else statement - is expected not to be else - .new - is expected to be a kind of RuboCop::AST::RescueNode - #branches - when there is an else - returns all the bodies - with an empty else - returns all the bodies - when there is no else keyword - returns only then rescue bodies - #resbody_branches + #branch_index + is expected to eq 0 + is expected to eq 1 is expected to eq 2 - is expected to all be resbody type - -RuboCop::AST::RuboCopCompatibility - when ran from a compatible version of Rubocop - issues a warning - when ran from an incompatible version of Rubocop - issues a warning - -RuboCop::AST::Procarg0Node - #name - is expected to eq :x - .new - with a block - is expected to be a kind of RuboCop::AST::ArgNode - -RuboCop::AST::NodePattern::Parser - sequences - parses simple sequences properly - parses unions of literals as a set - parses function calls - generates specialized nodes - parses capture vs repetition with correct priority - expands ... in sequence head deep inside unions -RuboCop::AST::OpAsgnNode - #operator - with /= - is expected to eq :/ - with += - is expected to eq :+ - with -= - is expected to eq :- - with %= - is expected to eq :% - with **= - is expected to eq :** - with &= - is expected to eq :& - with |= - is expected to eq :| - with *= - is expected to eq :* +RuboCop::AST::DefinedNode + #arguments + is expected to eq 1 + is expected to all be sym type .new - with an `op_asgn_node` node - is expected to be a kind of RuboCop::AST::OpAsgnNode - #expression - is expected to eq s(:send, nil, :value) - #name - is expected to eq :var - #assignment_node - is expected to be a kind of RuboCop::AST::AsgnNode - -RuboCop::AST::Node - sibling_access - returns trivial values for a root node - for a single child - returns the expected values - for a node with siblings - returns the expected values - #class_constructor? - module definition with a block - matches - class definition on outer scope - matches - class definition with a block - matches - class definition - does not match - #value_used? - within a module definition node - is always true - within a class definition node - is always true - within a method call node - is always true - within an if...else..end node - at the top level - is true only for the condition - nested in a method call - is always true - within a singleton class node - is always true - at the end of a block - is always true - within an array literal - at the top level - is always false - assigned to an ivar - is always true - within a while node - is true only for the condition - at the top level - is false - #numeric_type? - when integer literal - is true - when string literal - is true - when float literal - is true - when rational literal - is true - when complex literal whose imaginary part is a rational - is true - when complex literal - is true - #argument_type? - block arguments - returns true for all argument types - method arguments - returns true for all argument types - #parent_module_name - when node nested in a class << exp - is expected to be nil - when node on top level - is expected to eq "Object" - when node on class in singleton class - is expected to eq "Foo::#::Bar" - when node on module - is expected to eq "Foo" - when node nested in an unknown block - is expected to be nil - when node on singleton class - is expected to eq "Foo::#" - #conditional? - when post condition loop node - is false - when `if` node - is true - when `while` node - is true - when `until` node - is true - when `case` node - is true - when `case_match` node - is true - #module_definition? - using module keyword - matches - nested modules - matches - included module definition - matches - with Module.new - matches - when using numbered parameter - matches - prepend Module.new - matches - namespaced modules - matches - with ::ModuleName - matches - #recursive_basic_literal? - behaves like non literal - returns false for `some_method_call` - behaves like literal - returns true for `!true` - behaves like literal - returns true for `(false or true)` - behaves like literal - returns true for `(1)` - behaves like non literal - returns false for `(x == false)` - behaves like non literal - returns false for `[some_method_call]` - behaves like literal - returns true for `/./` - behaves like non literal - returns false for `%r{abx#{foo}}ixo` - behaves like literal - returns true for `(false <=> true)` - behaves like literal - returns true for `false` - behaves like non literal - returns false for `{ some_method_call => :sym }` - behaves like non literal - returns false for `/.#{some_method_call}/` - behaves like literal - returns true for `1.0` - behaves like literal - returns true for `(false && true)` - behaves like literal - returns true for `nil` - behaves like literal - returns true for `{ :a => 1, :b => 2 }` - behaves like literal - returns true for `1` - behaves like literal - returns true for `{ a: 1, b: 2 }` - behaves like non literal - returns false for `{ :sym => some_method_call }` - behaves like non literal - returns false for `some_method_call(x, y)` - behaves like literal - returns true for `[1, 2, 3]` - behaves like non literal - returns false for `(x or false)` - behaves like literal - returns true for `%r{abx}ixo` - behaves like literal - returns true for `'str'` - behaves like non literal - returns false for `(x && false)` - behaves like literal - returns true for `"#{2}"` - #pure? - for a hash literal - with only literal children - returns true - which contains a method call - returns false - for a gvar assignment - returns false - for an array literal - with only literal children - returns true - which contains a method call - returns false - for an integer literal - returns true - for a cvar assignment - returns false - for a class definition - returns false - for a module definition - returns false - for an lvar assignment - returns false - for an ivar assignment - returns false - for a nested if - where one branch contains a method call - returns false - where one branch contains an assignment statement - returns false - where the innermost descendants are local vars and literals - returns true - for a method call - returns false - for a regexp - with options - returns true - with interpolated segments - returns false - with no interpolation - returns true - #class_definition? - with Class.new - matches - when using numbered parameter - matches - constant defined as Struct without block - does not match - with self singleton class - matches - with Struct - matches - when using numbered parameter - matches - with object singleton class - matches - with ::ClassName - matches - namespaced class - matches - without inheritance - matches - with inheritance - matches - #struct_constructor? - ::Struct - matches - struct definition with a block - matches - struct definition without block - does not match - -RuboCop::AST::Ext::Range - #line_span - returns the range of lines a range occupies - accepts an `exclude_end` keyword argument - -RuboCop::AST::ForwardArgsNode - when using Ruby 2.7 or newer - #to_a - is expected to contain exactly (be forward arg type) - -RuboCop::AST::ConstNode - #each_path - yields all parts of the namespace - #absolute? - is expected to be absolute - with a non-namespaced constant - is expected not to be absolute - with a constant not starting with :: - is expected not to be absolute - #namespace - is expected to eq "::Foo::Bar" - #module_name? - is expected not to be module name - with a constant with a lowercase letter - is expected to be module name - #short_name - is expected to eq :BAZ - #relative? - with a non-namespaced constant - is expected to be relative + with a defined? node + is expected to be a kind of RuboCop::AST::DefinedNode + #method_name + is expected to eq :defined? + #receiver + is expected to be nil -Finished in 3.83 seconds (files took 1.2 seconds to load) +Finished in 10.94 seconds (files took 4.18 seconds to load) 2392 examples, 0 failures -Randomized with seed 46892 +Randomized with seed 53969 ┌──────────────────────────────────────────────────────────────────────────────┐ @@ -6564,12 +6600,14 @@ dpkg-buildpackage: info: binary-only upload (no source included) dpkg-genchanges: info: not including original source code in upload I: copying local configuration +I: user script /srv/workspace/pbuilder/1444777/tmp/hooks/B01_cleanup starting +I: user script /srv/workspace/pbuilder/1444777/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/2262698 and its subdirectories -I: Current time: Mon May 20 19:53:33 -12 2024 -I: pbuilder-time-stamp: 1716278013 +I: removing directory /srv/workspace/pbuilder/1444777 and its subdirectories +I: Current time: Tue Jun 24 04:18:58 +14 2025 +I: pbuilder-time-stamp: 1750688338